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/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469
 470
 471 // add here SWIG version check
 472
 473 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 474 // disable Swig-dependent warnings
 475
 476 // 'identifier1' has C-linkage specified,
 477 // but returns UDT 'identifier2' which is incompatible with C
 478 #pragma warning(disable: 4190)
 479
 480 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 481 #pragma warning(disable: 4800)
 482
 483 // debug info too long etc etc
 484 #pragma warning(disable: 4786)
 485 #endif
 486
 487
 488 #include <stdexcept>
 489
 490
 491 #include <string>
 492
 493
 494 #include <vector>
 495 #include <algorithm>
 496 #include <stdexcept>
 497
 498
 499 #include <map>
 500 #include <algorithm>
 501 #include <stdexcept>
 502
 503
 504 #include <utility>
 505
 506
 507 typedef float floatp;
 508
 509 SWIGINTERN floatp *new_floatp(){
 510   return new float();
 511 }
 512 SWIGINTERN void delete_floatp(floatp *self){
 513   if (self) delete self;
 514 }
 515 SWIGINTERN void floatp_assign(floatp *self,float value){
 516   *self = value;
 517 }
 518 SWIGINTERN float floatp_value(floatp *self){
 519   return *self;
 520 }
 521 SWIGINTERN float *floatp_cast(floatp *self){
 522   return self;
 523 }
 524 SWIGINTERN floatp *floatp_frompointer(float *t){
 525   return (floatp *) t;
 526 }
 527
 528 typedef int intp;
 529
 530 SWIGINTERN intp *new_intp(){
 531   return new int();
 532 }
 533 SWIGINTERN void delete_intp(intp *self){
 534   if (self) delete self;
 535 }
 536 SWIGINTERN void intp_assign(intp *self,int value){
 537   *self = value;
 538 }
 539 SWIGINTERN int intp_value(intp *self){
 540   return *self;
 541 }
 542 SWIGINTERN int *intp_cast(intp *self){
 543   return self;
 544 }
 545 SWIGINTERN intp *intp_frompointer(int *t){
 546   return (intp *) t;
 547 }
 548
 549 typedef double doublep;
 550
 551 SWIGINTERN doublep *new_doublep(){
 552   return new double();
 553 }
 554 SWIGINTERN void delete_doublep(doublep *self){
 555   if (self) delete self;
 556 }
 557 SWIGINTERN void doublep_assign(doublep *self,double value){
 558   *self = value;
 559 }
 560 SWIGINTERN double doublep_value(doublep *self){
 561   return *self;
 562 }
 563 SWIGINTERN double *doublep_cast(doublep *self){
 564   return self;
 565 }
 566 SWIGINTERN doublep *doublep_frompointer(double *t){
 567   return (doublep *) t;
 568 }
 569
 570 typedef unsigned int uintp;
 571
 572 SWIGINTERN uintp *new_uintp(){
 573   return new unsigned int();
 574 }
 575 SWIGINTERN void delete_uintp(uintp *self){
 576   if (self) delete self;
 577 }
 578 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 579   *self = value;
 580 }
 581 SWIGINTERN unsigned int uintp_value(uintp *self){
 582   return *self;
 583 }
 584 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 585   return self;
 586 }
 587 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 588   return (uintp *) t;
 589 }
 590
 591 typedef unsigned short ushortp;
 592
 593 SWIGINTERN ushortp *new_ushortp(){
 594   return new unsigned short();
 595 }
 596 SWIGINTERN void delete_ushortp(ushortp *self){
 597   if (self) delete self;
 598 }
 599 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 600   *self = value;
 601 }
 602 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 603   return *self;
 604 }
 605 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 606   return self;
 607 }
 608 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 609   return (ushortp *) t;
 610 }
 611
 612 unsigned int int_to_uint(int x) {
 613    return (unsigned int) x;
 614 }
 615
 616
 617 using namespace Dali;
 618 using namespace Dali::Toolkit;
 619
 620 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 621
 622      // C++ code. DALi uses Handle <-> Body design pattern.
 623      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 624      // Handles in DALi can be converted into a boolean type
 625      // to check if the handle has a valid body attached to it.
 626      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 627      if( *self )
 628      {
 629        return true;
 630      }
 631      else
 632      {
 633        return false;
 634      }
 635     }
 636 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 637
 638      // C++ code. Check if two handles reference the same implemtion
 639      if( *self == rhs)
 640      {
 641        return true;
 642      }
 643      else
 644      {
 645        return false;
 646      }
 647     }
 648 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 649      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 650    }
 651 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){
 652      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 653    }
 654 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 655         std::vector< Dali::TouchPoint >* pv = 0;
 656         if (capacity >= 0) {
 657           pv = new std::vector< Dali::TouchPoint >();
 658           pv->reserve(capacity);
 659        } else {
 660           throw std::out_of_range("capacity");
 661        }
 662        return pv;
 663       }
 664 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 665         if (index>=0 && index<(int)self->size())
 666           return (*self)[index];
 667         else
 668           throw std::out_of_range("index");
 669       }
 670 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 671         if (index>=0 && index<(int)self->size())
 672           return (*self)[index];
 673         else
 674           throw std::out_of_range("index");
 675       }
 676 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 677         if (index>=0 && index<(int)self->size())
 678           (*self)[index] = val;
 679         else
 680           throw std::out_of_range("index");
 681       }
 682 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 683         self->insert(self->end(), values.begin(), values.end());
 684       }
 685 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 686         if (index < 0)
 687           throw std::out_of_range("index");
 688         if (count < 0)
 689           throw std::out_of_range("count");
 690         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 691           throw std::invalid_argument("invalid range");
 692         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 693       }
 694 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 695         if (index>=0 && index<(int)self->size()+1)
 696           self->insert(self->begin()+index, x);
 697         else
 698           throw std::out_of_range("index");
 699       }
 700 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 701         if (index>=0 && index<(int)self->size()+1)
 702           self->insert(self->begin()+index, values.begin(), values.end());
 703         else
 704           throw std::out_of_range("index");
 705       }
 706 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 707         if (index>=0 && index<(int)self->size())
 708           self->erase(self->begin() + index);
 709         else
 710           throw std::out_of_range("index");
 711       }
 712 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 713         if (index < 0)
 714           throw std::out_of_range("index");
 715         if (count < 0)
 716           throw std::out_of_range("count");
 717         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 718           throw std::invalid_argument("invalid range");
 719         self->erase(self->begin()+index, self->begin()+index+count);
 720       }
 721 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 722         if (count < 0)
 723           throw std::out_of_range("count");
 724         return new std::vector< Dali::TouchPoint >(count, value);
 725       }
 726 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 727         std::reverse(self->begin(), self->end());
 728       }
 729 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 730         if (index < 0)
 731           throw std::out_of_range("index");
 732         if (count < 0)
 733           throw std::out_of_range("count");
 734         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 735           throw std::invalid_argument("invalid range");
 736         std::reverse(self->begin()+index, self->begin()+index+count);
 737       }
 738 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 739         if (index < 0)
 740           throw std::out_of_range("index");
 741         if (index+values.size() > self->size())
 742           throw std::out_of_range("index");
 743         std::copy(values.begin(), values.end(), self->begin()+index);
 744       }
 745 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 746          return self->Empty();
 747       }
 748 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 749         return self->GetConnectionCount();
 750       }
 751 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 752           self->Connect( func );
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 755           self->Disconnect( func );
 756       }
 757 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 758           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 759 /*@SWIG@*/ self->Emit( arg );
 760       }
 761 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 762          return self->Empty();
 763       }
 764 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 765         return self->GetConnectionCount();
 766       }
 767 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 768           self->Connect( func );
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 771           self->Disconnect( func );
 772       }
 773 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 774           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 775 /*@SWIG@*/ self->Emit( arg );
 776       }
 777 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 778          return self->Empty();
 779       }
 780 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){
 781         return self->GetConnectionCount();
 782       }
 783 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 *)){
 784           self->Connect( func );
 785       }
 786 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 *)){
 787           self->Disconnect( func );
 788       }
 789 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){
 790           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 791 /*@SWIG@*/ self->Emit( arg );
 792       }
 793 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 794          return self->Empty();
 795       }
 796 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 797         return self->GetConnectionCount();
 798       }
 799 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 800           self->Connect( func );
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 803           self->Disconnect( func );
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 806           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 807 /*@SWIG@*/ self->Emit( arg );
 808       }
 809 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 810          return self->Empty();
 811       }
 812 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 813         return self->GetConnectionCount();
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 816           self->Connect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 819           self->Disconnect( func );
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 822           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 823 /*@SWIG@*/ self->Emit( arg );
 824       }
 825 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){
 826          return self->Empty();
 827       }
 828 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){
 829         return self->GetConnectionCount();
 830       }
 831 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 &)){
 832         self->Connect( func );
 833       }
 834 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 &)){
 835         self->Disconnect( func );
 836       }
 837 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){
 838         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 839 /*@SWIG@*/ self->Emit( arg1, arg2 );
 840       }
 841 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){
 842          return self->Empty();
 843       }
 844 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){
 845         return self->GetConnectionCount();
 846       }
 847 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 &)){
 848         self->Connect( func );
 849       }
 850 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 &)){
 851         self->Disconnect( func );
 852       }
 853 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){
 854         return self->Emit( arg1, arg2 );
 855       }
 856 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){
 857          return self->Empty();
 858       }
 859 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){
 860         return self->GetConnectionCount();
 861       }
 862 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 &)){
 863         self->Connect( func );
 864       }
 865 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 &)){
 866         self->Disconnect( func );
 867       }
 868 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){
 869         return self->Emit( arg1, arg2 );
 870       }
 871 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){
 872          return self->Empty();
 873       }
 874 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){
 875         return self->GetConnectionCount();
 876       }
 877 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 &)){
 878         self->Connect( func );
 879       }
 880 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 &)){
 881         self->Disconnect( func );
 882       }
 883 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){
 884         return self->Emit( arg1, arg2 );
 885       }
 886 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 887          return self->Empty();
 888       }
 889 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 890         return self->GetConnectionCount();
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 893           self->Connect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 896           self->Disconnect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 899           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg );
 901       }
 902 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 903          return self->Empty();
 904       }
 905 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){
 906         return self->GetConnectionCount();
 907       }
 908 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 &)){
 909           self->Connect( func );
 910       }
 911 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 &)){
 912           self->Disconnect( func );
 913       }
 914 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){
 915           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 916 /*@SWIG@*/ self->Emit( arg );
 917       }
 918 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 919          return self->Empty();
 920       }
 921 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){
 922         return self->GetConnectionCount();
 923       }
 924 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 &)){
 925           self->Connect( func );
 926       }
 927 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 &)){
 928           self->Disconnect( func );
 929       }
 930 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){
 931           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 932 /*@SWIG@*/ self->Emit( arg );
 933       }
 934 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 935          return self->Empty();
 936       }
 937 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){
 938         return self->GetConnectionCount();
 939       }
 940 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 &)){
 941           self->Connect( func );
 942       }
 943 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 &)){
 944           self->Disconnect( func );
 945       }
 946 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){
 947           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 948 /*@SWIG@*/ self->Emit( arg );
 949       }
 950 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){
 951          return self->Empty();
 952       }
 953 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){
 954         return self->GetConnectionCount();
 955       }
 956 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 &)){
 957         self->Connect( func );
 958       }
 959 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 &)){
 960         self->Disconnect( func );
 961       }
 962 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){
 963         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 964 /*@SWIG@*/ self->Emit( arg1, arg2 );
 965       }
 966 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){
 967          return self->Empty();
 968       }
 969 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){
 970         return self->GetConnectionCount();
 971       }
 972 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 &)){
 973         self->Connect( func );
 974       }
 975 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 &)){
 976         self->Disconnect( func );
 977       }
 978 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){
 979         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 980 /*@SWIG@*/ self->Emit( arg1, arg2 );
 981       }
 982 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){
 983          return self->Empty();
 984       }
 985 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){
 986         return self->GetConnectionCount();
 987       }
 988 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 &)){
 989         self->Connect( func );
 990       }
 991 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 &)){
 992         self->Disconnect( func );
 993       }
 994 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){
 995         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 996 /*@SWIG@*/ self->Emit( arg1, arg2 );
 997       }
 998 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 999          return self->Empty();
1000       }
1001 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1002         return self->GetConnectionCount();
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1005           self->Connect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1008           self->Disconnect( func );
1009       }
1010 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1011           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1012 /*@SWIG@*/ self->Emit( arg );
1013       }
1014 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){
1015          return self->Empty();
1016       }
1017 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){
1018         return self->GetConnectionCount();
1019       }
1020 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)){
1021           return self->Connect( func );
1022       }
1023 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)){
1024           self->Disconnect( func );
1025       }
1026 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){
1027           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1028 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1029       }
1030
1031 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1032          return self->Empty();
1033       }
1034 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1035         return self->GetConnectionCount();
1036       }
1037 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1038           self->Connect( func );
1039       }
1040 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1041           self->Disconnect( func );
1042       }
1043 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1044           return self->Emit();
1045       }
1046
1047 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1048         std::vector< unsigned int >* pv = 0;
1049         if (capacity >= 0) {
1050           pv = new std::vector< unsigned int >();
1051           pv->reserve(capacity);
1052        } else {
1053           throw std::out_of_range("capacity");
1054        }
1055        return pv;
1056       }
1057 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1058         if (index>=0 && index<(int)self->size())
1059           return (*self)[index];
1060         else
1061           throw std::out_of_range("index");
1062       }
1063 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1064         if (index>=0 && index<(int)self->size())
1065           return (*self)[index];
1066         else
1067           throw std::out_of_range("index");
1068       }
1069 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1070         if (index>=0 && index<(int)self->size())
1071           (*self)[index] = val;
1072         else
1073           throw std::out_of_range("index");
1074       }
1075 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1076         self->insert(self->end(), values.begin(), values.end());
1077       }
1078 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1079         if (index < 0)
1080           throw std::out_of_range("index");
1081         if (count < 0)
1082           throw std::out_of_range("count");
1083         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1084           throw std::invalid_argument("invalid range");
1085         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1086       }
1087 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1088         if (index>=0 && index<(int)self->size()+1)
1089           self->insert(self->begin()+index, x);
1090         else
1091           throw std::out_of_range("index");
1092       }
1093 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1094         if (index>=0 && index<(int)self->size()+1)
1095           self->insert(self->begin()+index, values.begin(), values.end());
1096         else
1097           throw std::out_of_range("index");
1098       }
1099 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1100         if (index>=0 && index<(int)self->size())
1101           self->erase(self->begin() + index);
1102         else
1103           throw std::out_of_range("index");
1104       }
1105 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1106         if (index < 0)
1107           throw std::out_of_range("index");
1108         if (count < 0)
1109           throw std::out_of_range("count");
1110         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1111           throw std::invalid_argument("invalid range");
1112         self->erase(self->begin()+index, self->begin()+index+count);
1113       }
1114 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1115         if (count < 0)
1116           throw std::out_of_range("count");
1117         return new std::vector< unsigned int >(count, value);
1118       }
1119 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1120         std::reverse(self->begin(), self->end());
1121       }
1122 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1123         if (index < 0)
1124           throw std::out_of_range("index");
1125         if (count < 0)
1126           throw std::out_of_range("count");
1127         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1128           throw std::invalid_argument("invalid range");
1129         std::reverse(self->begin()+index, self->begin()+index+count);
1130       }
1131 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1132         if (index < 0)
1133           throw std::out_of_range("index");
1134         if (index+values.size() > self->size())
1135           throw std::out_of_range("index");
1136         std::copy(values.begin(), values.end(), self->begin()+index);
1137       }
1138 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1139         return std::find(self->begin(), self->end(), value) != self->end();
1140       }
1141 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1142         int index = -1;
1143         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1144         if (it != self->end())
1145           index = (int)(it - self->begin());
1146         return index;
1147       }
1148 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1149         int index = -1;
1150         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1151         if (rit != self->rend())
1152           index = (int)(self->rend() - 1 - rit);
1153         return index;
1154       }
1155 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1156         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1157         if (it != self->end()) {
1158           self->erase(it);
1159           return true;
1160         }
1161         return false;
1162       }
1163 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){
1164         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1165         if (capacity >= 0) {
1166           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1167           pv->reserve(capacity);
1168        } else {
1169           throw std::out_of_range("capacity");
1170        }
1171        return pv;
1172       }
1173 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){
1174         if (index>=0 && index<(int)self->size())
1175           return (*self)[index];
1176         else
1177           throw std::out_of_range("index");
1178       }
1179 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){
1180         if (index>=0 && index<(int)self->size())
1181           return (*self)[index];
1182         else
1183           throw std::out_of_range("index");
1184       }
1185 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){
1186         if (index>=0 && index<(int)self->size())
1187           (*self)[index] = val;
1188         else
1189           throw std::out_of_range("index");
1190       }
1191 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){
1192         self->insert(self->end(), values.begin(), values.end());
1193       }
1194 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){
1195         if (index < 0)
1196           throw std::out_of_range("index");
1197         if (count < 0)
1198           throw std::out_of_range("count");
1199         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1200           throw std::invalid_argument("invalid range");
1201         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1202       }
1203 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){
1204         if (index>=0 && index<(int)self->size()+1)
1205           self->insert(self->begin()+index, x);
1206         else
1207           throw std::out_of_range("index");
1208       }
1209 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){
1210         if (index>=0 && index<(int)self->size()+1)
1211           self->insert(self->begin()+index, values.begin(), values.end());
1212         else
1213           throw std::out_of_range("index");
1214       }
1215 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){
1216         if (index>=0 && index<(int)self->size())
1217           self->erase(self->begin() + index);
1218         else
1219           throw std::out_of_range("index");
1220       }
1221 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){
1222         if (index < 0)
1223           throw std::out_of_range("index");
1224         if (count < 0)
1225           throw std::out_of_range("count");
1226         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1227           throw std::invalid_argument("invalid range");
1228         self->erase(self->begin()+index, self->begin()+index+count);
1229       }
1230 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){
1231         if (count < 0)
1232           throw std::out_of_range("count");
1233         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1234       }
1235 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){
1236         std::reverse(self->begin(), self->end());
1237       }
1238 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){
1239         if (index < 0)
1240           throw std::out_of_range("index");
1241         if (count < 0)
1242           throw std::out_of_range("count");
1243         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1244           throw std::invalid_argument("invalid range");
1245         std::reverse(self->begin()+index, self->begin()+index+count);
1246       }
1247 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){
1248         if (index < 0)
1249           throw std::out_of_range("index");
1250         if (index+values.size() > self->size())
1251           throw std::out_of_range("index");
1252         std::copy(values.begin(), values.end(), self->begin()+index);
1253       }
1254 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1255         std::vector< Dali::Actor >* pv = 0;
1256         if (capacity >= 0) {
1257           pv = new std::vector< Dali::Actor >();
1258           pv->reserve(capacity);
1259        } else {
1260           throw std::out_of_range("capacity");
1261        }
1262        return pv;
1263       }
1264 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1265         if (index>=0 && index<(int)self->size())
1266           return (*self)[index];
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1271         if (index>=0 && index<(int)self->size())
1272           return (*self)[index];
1273         else
1274           throw std::out_of_range("index");
1275       }
1276 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1277         if (index>=0 && index<(int)self->size())
1278           (*self)[index] = val;
1279         else
1280           throw std::out_of_range("index");
1281       }
1282 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1283         self->insert(self->end(), values.begin(), values.end());
1284       }
1285 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1286         if (index < 0)
1287           throw std::out_of_range("index");
1288         if (count < 0)
1289           throw std::out_of_range("count");
1290         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1291           throw std::invalid_argument("invalid range");
1292         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1293       }
1294 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1295         if (index>=0 && index<(int)self->size()+1)
1296           self->insert(self->begin()+index, x);
1297         else
1298           throw std::out_of_range("index");
1299       }
1300 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1301         if (index>=0 && index<(int)self->size()+1)
1302           self->insert(self->begin()+index, values.begin(), values.end());
1303         else
1304           throw std::out_of_range("index");
1305       }
1306 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1307         if (index>=0 && index<(int)self->size())
1308           self->erase(self->begin() + index);
1309         else
1310           throw std::out_of_range("index");
1311       }
1312 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1313         if (index < 0)
1314           throw std::out_of_range("index");
1315         if (count < 0)
1316           throw std::out_of_range("count");
1317         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1318           throw std::invalid_argument("invalid range");
1319         self->erase(self->begin()+index, self->begin()+index+count);
1320       }
1321 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1322         if (count < 0)
1323           throw std::out_of_range("count");
1324         return new std::vector< Dali::Actor >(count, value);
1325       }
1326 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1327         std::reverse(self->begin(), self->end());
1328       }
1329 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1330         if (index < 0)
1331           throw std::out_of_range("index");
1332         if (count < 0)
1333           throw std::out_of_range("count");
1334         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1335           throw std::invalid_argument("invalid range");
1336         std::reverse(self->begin()+index, self->begin()+index+count);
1337       }
1338 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1339         if (index < 0)
1340           throw std::out_of_range("index");
1341         if (index+values.size() > self->size())
1342           throw std::out_of_range("index");
1343         std::copy(values.begin(), values.end(), self->begin()+index);
1344       }
1345 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1346          return self->Empty();
1347       }
1348 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1349         return self->GetConnectionCount();
1350       }
1351 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 &)){
1352           self->Connect( func );
1353       }
1354 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 &)){
1355           self->Disconnect( func );
1356       }
1357 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){
1358           return self->Emit( arg );
1359       }
1360 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){
1361          return self->Empty();
1362       }
1363 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){
1364         return self->GetConnectionCount();
1365       }
1366 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)){
1367         self->Connect( func );
1368       }
1369 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)){
1370         self->Disconnect( func );
1371       }
1372 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){
1373         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1374 /*@SWIG@*/ self->Emit( arg1, arg2 );
1375       }
1376 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1377          return self->Empty();
1378       }
1379 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){
1380         return self->GetConnectionCount();
1381       }
1382 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)){
1383         self->Connect( func );
1384       }
1385 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)){
1386         self->Disconnect( func );
1387       }
1388 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){
1389         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1390 /*@SWIG@*/ self->Emit( arg1, arg2 );
1391       }
1392 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1393          return self->Empty();
1394       }
1395 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1396         return self->GetConnectionCount();
1397       }
1398 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)){
1399         self->Connect( func );
1400       }
1401 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)){
1402         self->Disconnect( func );
1403       }
1404 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){
1405         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1406 /*@SWIG@*/ self->Emit( arg1, arg2 );
1407       }
1408 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){
1409          return self->Empty();
1410       }
1411 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){
1412         return self->GetConnectionCount();
1413       }
1414 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)){
1415         self->Connect( func );
1416       }
1417 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)){
1418         self->Disconnect( func );
1419       }
1420 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){
1421         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1422 /*@SWIG@*/ self->Emit( arg1, arg2 );
1423       }
1424 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1425          return self->Empty();
1426       }
1427 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1428         return self->GetConnectionCount();
1429       }
1430 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)){
1431           self->Connect( func );
1432       }
1433 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)){
1434           self->Disconnect( func );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1437           return self->Emit( arg );
1438       }
1439 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1440          return self->Empty();
1441       }
1442 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1443         return self->GetConnectionCount();
1444       }
1445 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)){
1446           self->Connect( func );
1447       }
1448 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)){
1449           self->Disconnect( func );
1450       }
1451 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1452           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1453 /*@SWIG@*/ self->Emit( arg );
1454       }
1455 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){
1456          return self->Empty();
1457       }
1458 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){
1459         return self->GetConnectionCount();
1460       }
1461 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)){
1462           return self->Connect( func );
1463       }
1464 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)){
1465           self->Disconnect( func );
1466       }
1467 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){
1468           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1469 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1470       }
1471 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1472          return self->Empty();
1473       }
1474 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1475         return self->GetConnectionCount();
1476       }
1477 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)){
1478           self->Connect( func );
1479       }
1480 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)){
1481           self->Disconnect( func );
1482       }
1483 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1484           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1485 /*@SWIG@*/ self->Emit( arg );
1486       }
1487 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){
1488          return self->Empty();
1489       }
1490 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){
1491         return self->GetConnectionCount();
1492       }
1493 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)){
1494           return self->Connect( func );
1495       }
1496 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)){
1497           self->Disconnect( func );
1498       }
1499 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){
1500           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1501 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1502       }
1503 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){
1504          return self->Empty();
1505       }
1506 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){
1507         return self->GetConnectionCount();
1508       }
1509 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 &)){
1510           self->Connect( func );
1511       }
1512 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 &)){
1513           self->Disconnect( func );
1514       }
1515 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){
1516           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1517 /*@SWIG@*/ self->Emit( arg );
1518       }
1519 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1520          return self->Empty();
1521       }
1522 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){
1523         return self->GetConnectionCount();
1524       }
1525 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 &)){
1526           self->Connect( func );
1527       }
1528 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 &)){
1529           self->Disconnect( func );
1530       }
1531 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){
1532           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1533 /*@SWIG@*/ self->Emit( arg );
1534       }
1535
1536
1537 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){
1538          return self->Empty();
1539       }
1540 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){
1541         return self->GetConnectionCount();
1542       }
1543 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 &)){
1544         self->Connect( func );
1545       }
1546 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 &)){
1547         self->Disconnect( func );
1548       }
1549 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){
1550         return self->Emit( arg1, arg2 );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 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)){
1559           self->Connect( func );
1560       }
1561 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)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1569          return self->Empty();
1570       }
1571 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575           self->Connect( func );
1576       }
1577 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 &)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1585          return self->Empty();
1586       }
1587 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){
1588         return self->GetConnectionCount();
1589       }
1590 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)){
1591         self->Connect( func );
1592       }
1593 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)){
1594         self->Disconnect( func );
1595       }
1596 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){
1597         return self->Emit( arg1, arg2 );
1598       }
1599 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1600          return self->Empty();
1601       }
1602 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){
1603         return self->GetConnectionCount();
1604       }
1605 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)){
1606         self->Connect( func );
1607       }
1608 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)){
1609         self->Disconnect( func );
1610       }
1611 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){
1612         return self->Emit( arg1, arg2 );
1613       }
1614
1615
1616 /* ---------------------------------------------------
1617  * C++ director class methods
1618  * --------------------------------------------------- */
1619
1620 #include "dali_wrap.h"
1621
1622 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1623   swig_init_callbacks();
1624 }
1625
1626 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1627
1628 }
1629
1630
1631 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1632   int jdepth  ;
1633
1634   if (!swig_callbackOnStageConnection) {
1635     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1636     return;
1637   } else {
1638     jdepth = depth;
1639     swig_callbackOnStageConnection(jdepth);
1640   }
1641 }
1642
1643 void SwigDirector_ViewImpl::OnStageDisconnection() {
1644   if (!swig_callbackOnStageDisconnection) {
1645     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1646     return;
1647   } else {
1648     swig_callbackOnStageDisconnection();
1649   }
1650 }
1651
1652 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1653   void * jchild = 0 ;
1654
1655   if (!swig_callbackOnChildAdd) {
1656     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1657     return;
1658   } else {
1659     jchild = (Dali::Actor *) &child;
1660     swig_callbackOnChildAdd(jchild);
1661   }
1662 }
1663
1664 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1665   void * jchild = 0 ;
1666
1667   if (!swig_callbackOnChildRemove) {
1668     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1669     return;
1670   } else {
1671     jchild = (Dali::Actor *) &child;
1672     swig_callbackOnChildRemove(jchild);
1673   }
1674 }
1675
1676 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1677   int jindex  ;
1678   void * jpropertyValue  ;
1679
1680   if (!swig_callbackOnPropertySet) {
1681     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1682     return;
1683   } else {
1684     jindex = index;
1685     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1686     swig_callbackOnPropertySet(jindex, jpropertyValue);
1687   }
1688 }
1689
1690 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1691   void * jtargetSize = 0 ;
1692
1693   if (!swig_callbackOnSizeSet) {
1694     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1695     return;
1696   } else {
1697     jtargetSize = (Dali::Vector3 *) &targetSize;
1698     swig_callbackOnSizeSet(jtargetSize);
1699   }
1700 }
1701
1702 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1703   void * janimation = 0 ;
1704   void * jtargetSize = 0 ;
1705
1706   if (!swig_callbackOnSizeAnimation) {
1707     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1708     return;
1709   } else {
1710     janimation = (Dali::Animation *) &animation;
1711     jtargetSize = (Dali::Vector3 *) &targetSize;
1712     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1713   }
1714 }
1715
1716 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1717   bool c_result = SwigValueInit< bool >() ;
1718   unsigned int jresult = 0 ;
1719   void * jarg0 = 0 ;
1720
1721   if (!swig_callbackOnTouchEvent) {
1722     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1723   } else {
1724     jarg0 = (Dali::TouchEvent *) &event;
1725     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1726     c_result = jresult ? true : false;
1727   }
1728   return c_result;
1729 }
1730
1731 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1732   bool c_result = SwigValueInit< bool >() ;
1733   unsigned int jresult = 0 ;
1734   void * jarg0 = 0 ;
1735
1736   if (!swig_callbackOnHoverEvent) {
1737     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1738   } else {
1739     jarg0 = (Dali::HoverEvent *) &event;
1740     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1741     c_result = jresult ? true : false;
1742   }
1743   return c_result;
1744 }
1745
1746 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1747   bool c_result = SwigValueInit< bool >() ;
1748   unsigned int jresult = 0 ;
1749   void * jarg0 = 0 ;
1750
1751   if (!swig_callbackOnKeyEvent) {
1752     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1753   } else {
1754     jarg0 = (Dali::KeyEvent *) &event;
1755     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1756     c_result = jresult ? true : false;
1757   }
1758   return c_result;
1759 }
1760
1761 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1762   bool c_result = SwigValueInit< bool >() ;
1763   unsigned int jresult = 0 ;
1764   void * jarg0 = 0 ;
1765
1766   if (!swig_callbackOnWheelEvent) {
1767     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1768   } else {
1769     jarg0 = (Dali::WheelEvent *) &event;
1770     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1771     c_result = jresult ? true : false;
1772   }
1773   return c_result;
1774 }
1775
1776 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1777   void * jsize = 0 ;
1778   void * jcontainer = 0 ;
1779
1780   if (!swig_callbackOnRelayout) {
1781     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1782     return;
1783   } else {
1784     jsize = (Dali::Vector2 *) &size;
1785     jcontainer = (Dali::RelayoutContainer *) &container;
1786     swig_callbackOnRelayout(jsize, jcontainer);
1787   }
1788 }
1789
1790 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1791   int jpolicy  ;
1792   int jdimension  ;
1793
1794   if (!swig_callbackOnSetResizePolicy) {
1795     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1796     return;
1797   } else {
1798     jpolicy = (int)policy;
1799     jdimension = (int)dimension;
1800     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1801   }
1802 }
1803
1804 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1805   Dali::Vector3 c_result ;
1806   void * jresult = 0 ;
1807
1808   if (!swig_callbackGetNaturalSize) {
1809     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1810   } else {
1811     jresult = (void *) swig_callbackGetNaturalSize();
1812     if (!jresult) {
1813       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1814       return c_result;
1815     }
1816     c_result = *(Dali::Vector3 *)jresult;
1817   }
1818   return c_result;
1819 }
1820
1821 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1822   float c_result = SwigValueInit< float >() ;
1823   float jresult = 0 ;
1824   void * jchild = 0 ;
1825   int jdimension  ;
1826
1827   if (!swig_callbackCalculateChildSize) {
1828     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1829   } else {
1830     jchild = (Dali::Actor *) &child;
1831     jdimension = (int)dimension;
1832     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1833     c_result = (float)jresult;
1834   }
1835   return c_result;
1836 }
1837
1838 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1839   float c_result = SwigValueInit< float >() ;
1840   float jresult = 0 ;
1841   float jwidth  ;
1842
1843   if (!swig_callbackGetHeightForWidth) {
1844     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1845   } else {
1846     jwidth = width;
1847     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1848     c_result = (float)jresult;
1849   }
1850   return c_result;
1851 }
1852
1853 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1854   float c_result = SwigValueInit< float >() ;
1855   float jresult = 0 ;
1856   float jheight  ;
1857
1858   if (!swig_callbackGetWidthForHeight) {
1859     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1860   } else {
1861     jheight = height;
1862     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1863     c_result = (float)jresult;
1864   }
1865   return c_result;
1866 }
1867
1868 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1869   bool c_result = SwigValueInit< bool >() ;
1870   unsigned int jresult = 0 ;
1871   int jdimension  ;
1872
1873   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1874     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1875   } else {
1876     jdimension = (int)dimension;
1877     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1878     c_result = jresult ? true : false;
1879   }
1880   return c_result;
1881 }
1882
1883 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1884   int jdimension  ;
1885
1886   if (!swig_callbackOnCalculateRelayoutSize) {
1887     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1888     return;
1889   } else {
1890     jdimension = (int)dimension;
1891     swig_callbackOnCalculateRelayoutSize(jdimension);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1896   float jsize  ;
1897   int jdimension  ;
1898
1899   if (!swig_callbackOnLayoutNegotiated) {
1900     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1901     return;
1902   } else {
1903     jsize = size;
1904     jdimension = (int)dimension;
1905     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1906   }
1907 }
1908
1909 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1910   return Dali::CustomActorImpl::GetExtension();
1911 }
1912
1913 void SwigDirector_ViewImpl::OnInitialize() {
1914   if (!swig_callbackOnInitialize) {
1915     Dali::Toolkit::Internal::Control::OnInitialize();
1916     return;
1917   } else {
1918     swig_callbackOnInitialize();
1919   }
1920 }
1921
1922 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1923   void * jchild = 0 ;
1924
1925   if (!swig_callbackOnControlChildAdd) {
1926     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1927     return;
1928   } else {
1929     jchild = (Dali::Actor *) &child;
1930     swig_callbackOnControlChildAdd(jchild);
1931   }
1932 }
1933
1934 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1935   void * jchild = 0 ;
1936
1937   if (!swig_callbackOnControlChildRemove) {
1938     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1939     return;
1940   } else {
1941     jchild = (Dali::Actor *) &child;
1942     swig_callbackOnControlChildRemove(jchild);
1943   }
1944 }
1945
1946 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1947   void * jstyleManager  ;
1948   int jchange  ;
1949
1950   if (!swig_callbackOnStyleChange) {
1951     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1952     return;
1953   } else {
1954     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1955     jchange = (int)change;
1956     swig_callbackOnStyleChange(jstyleManager, jchange);
1957   }
1958 }
1959
1960 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1961   bool c_result = SwigValueInit< bool >() ;
1962   unsigned int jresult = 0 ;
1963
1964   if (!swig_callbackOnAccessibilityActivated) {
1965     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1966   } else {
1967     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1968     c_result = jresult ? true : false;
1969   }
1970   return c_result;
1971 }
1972
1973 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1974   bool c_result = SwigValueInit< bool >() ;
1975   unsigned int jresult = 0 ;
1976   void * jgesture  ;
1977
1978   if (!swig_callbackOnAccessibilityPan) {
1979     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1980   } else {
1981     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
1982     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
1983     c_result = jresult ? true : false;
1984   }
1985   return c_result;
1986 }
1987
1988 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
1989   bool c_result = SwigValueInit< bool >() ;
1990   unsigned int jresult = 0 ;
1991   void * jtouchEvent = 0 ;
1992
1993   if (!swig_callbackOnAccessibilityTouch) {
1994     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
1995   } else {
1996     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
1997     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
1998     c_result = jresult ? true : false;
1999   }
2000   return c_result;
2001 }
2002
2003 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2004   bool c_result = SwigValueInit< bool >() ;
2005   unsigned int jresult = 0 ;
2006   unsigned int jisIncrease  ;
2007
2008   if (!swig_callbackOnAccessibilityValueChange) {
2009     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2010   } else {
2011     jisIncrease = isIncrease;
2012     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2013     c_result = jresult ? true : false;
2014   }
2015   return c_result;
2016 }
2017
2018 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2019   bool c_result = SwigValueInit< bool >() ;
2020   unsigned int jresult = 0 ;
2021
2022   if (!swig_callbackOnAccessibilityZoom) {
2023     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2024   } else {
2025     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2026     c_result = jresult ? true : false;
2027   }
2028   return c_result;
2029 }
2030
2031 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2032   if (!swig_callbackOnKeyInputFocusGained) {
2033     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2034     return;
2035   } else {
2036     swig_callbackOnKeyInputFocusGained();
2037   }
2038 }
2039
2040 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2041   if (!swig_callbackOnKeyInputFocusLost) {
2042     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2043     return;
2044   } else {
2045     swig_callbackOnKeyInputFocusLost();
2046   }
2047 }
2048
2049 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2050   Dali::Actor c_result ;
2051   void * jresult = 0 ;
2052   void * jcurrentFocusedActor  ;
2053   int jdirection  ;
2054   unsigned int jloopEnabled  ;
2055
2056   if (!swig_callbackGetNextKeyboardFocusableActor) {
2057     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2058   } else {
2059     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2060     jdirection = (int)direction;
2061     jloopEnabled = loopEnabled;
2062     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2063     if (!jresult) {
2064       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2065       return c_result;
2066     }
2067     c_result = *(Dali::Actor *)jresult;
2068   }
2069   return c_result;
2070 }
2071
2072 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2073   void * jcommitedFocusableActor  ;
2074
2075   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2076     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2077     return;
2078   } else {
2079     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2080     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2081   }
2082 }
2083
2084 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2085   bool c_result = SwigValueInit< bool >() ;
2086   unsigned int jresult = 0 ;
2087
2088   if (!swig_callbackOnKeyboardEnter) {
2089     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2090   } else {
2091     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2092     c_result = jresult ? true : false;
2093   }
2094   return c_result;
2095 }
2096
2097 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2098   void * jpinch = 0 ;
2099
2100   if (!swig_callbackOnPinch) {
2101     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2102     return;
2103   } else {
2104     jpinch = (Dali::PinchGesture *) &pinch;
2105     swig_callbackOnPinch(jpinch);
2106   }
2107 }
2108
2109 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2110   void * jpan = 0 ;
2111
2112   if (!swig_callbackOnPan) {
2113     Dali::Toolkit::Internal::Control::OnPan(pan);
2114     return;
2115   } else {
2116     jpan = (Dali::PanGesture *) &pan;
2117     swig_callbackOnPan(jpan);
2118   }
2119 }
2120
2121 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2122   void * jtap = 0 ;
2123
2124   if (!swig_callbackOnTap) {
2125     Dali::Toolkit::Internal::Control::OnTap(tap);
2126     return;
2127   } else {
2128     jtap = (Dali::TapGesture *) &tap;
2129     swig_callbackOnTap(jtap);
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2134   void * jlongPress = 0 ;
2135
2136   if (!swig_callbackOnLongPress) {
2137     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2138     return;
2139   } else {
2140     jlongPress = (Dali::LongPressGesture *) &longPress;
2141     swig_callbackOnLongPress(jlongPress);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2146   void * jslotObserver = 0 ;
2147   void * jcallback = 0 ;
2148
2149   if (!swig_callbackSignalConnected) {
2150     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2151     return;
2152   } else {
2153     jslotObserver = (void *) slotObserver;
2154     jcallback = (void *) callback;
2155     swig_callbackSignalConnected(jslotObserver, jcallback);
2156   }
2157 }
2158
2159 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2160   void * jslotObserver = 0 ;
2161   void * jcallback = 0 ;
2162
2163   if (!swig_callbackSignalDisconnected) {
2164     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2165     return;
2166   } else {
2167     jslotObserver = (void *) slotObserver;
2168     jcallback = (void *) callback;
2169     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2170   }
2171 }
2172
2173 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2174   return Dali::Toolkit::Internal::Control::GetControlExtension();
2175 }
2176
2177 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) {
2178   swig_callbackOnStageConnection = callbackOnStageConnection;
2179   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2180   swig_callbackOnChildAdd = callbackOnChildAdd;
2181   swig_callbackOnChildRemove = callbackOnChildRemove;
2182   swig_callbackOnPropertySet = callbackOnPropertySet;
2183   swig_callbackOnSizeSet = callbackOnSizeSet;
2184   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2185   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2186   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2187   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2188   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2189   swig_callbackOnRelayout = callbackOnRelayout;
2190   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2191   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2192   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2193   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2194   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2195   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2196   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2197   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2198   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2199   swig_callbackOnInitialize = callbackOnInitialize;
2200   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2201   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2202   swig_callbackOnStyleChange = callbackOnStyleChange;
2203   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2204   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2205   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2206   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2207   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2208   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2209   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2210   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2211   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2212   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2213   swig_callbackOnPinch = callbackOnPinch;
2214   swig_callbackOnPan = callbackOnPan;
2215   swig_callbackOnTap = callbackOnTap;
2216   swig_callbackOnLongPress = callbackOnLongPress;
2217   swig_callbackSignalConnected = callbackSignalConnected;
2218   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2219 }
2220
2221 void SwigDirector_ViewImpl::swig_init_callbacks() {
2222   swig_callbackOnStageConnection = 0;
2223   swig_callbackOnStageDisconnection = 0;
2224   swig_callbackOnChildAdd = 0;
2225   swig_callbackOnChildRemove = 0;
2226   swig_callbackOnPropertySet = 0;
2227   swig_callbackOnSizeSet = 0;
2228   swig_callbackOnSizeAnimation = 0;
2229   swig_callbackOnTouchEvent = 0;
2230   swig_callbackOnHoverEvent = 0;
2231   swig_callbackOnKeyEvent = 0;
2232   swig_callbackOnWheelEvent = 0;
2233   swig_callbackOnRelayout = 0;
2234   swig_callbackOnSetResizePolicy = 0;
2235   swig_callbackGetNaturalSize = 0;
2236   swig_callbackCalculateChildSize = 0;
2237   swig_callbackGetHeightForWidth = 0;
2238   swig_callbackGetWidthForHeight = 0;
2239   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2240   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2241   swig_callbackOnCalculateRelayoutSize = 0;
2242   swig_callbackOnLayoutNegotiated = 0;
2243   swig_callbackOnInitialize = 0;
2244   swig_callbackOnControlChildAdd = 0;
2245   swig_callbackOnControlChildRemove = 0;
2246   swig_callbackOnStyleChange = 0;
2247   swig_callbackOnAccessibilityActivated = 0;
2248   swig_callbackOnAccessibilityPan = 0;
2249   swig_callbackOnAccessibilityTouch = 0;
2250   swig_callbackOnAccessibilityValueChange = 0;
2251   swig_callbackOnAccessibilityZoom = 0;
2252   swig_callbackOnKeyInputFocusGained = 0;
2253   swig_callbackOnKeyInputFocusLost = 0;
2254   swig_callbackGetNextKeyboardFocusableActor = 0;
2255   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2256   swig_callbackOnKeyboardEnter = 0;
2257   swig_callbackOnPinch = 0;
2258   swig_callbackOnPan = 0;
2259   swig_callbackOnTap = 0;
2260   swig_callbackOnLongPress = 0;
2261   swig_callbackSignalConnected = 0;
2262   swig_callbackSignalDisconnected = 0;
2263 }
2264
2265 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2266   swig_init_callbacks();
2267 }
2268
2269 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2270
2271 }
2272
2273
2274 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2275   unsigned int c_result = SwigValueInit< unsigned int >() ;
2276   unsigned int jresult = 0 ;
2277
2278   if (!swig_callbackGetNumberOfItems) {
2279     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2280   } else {
2281     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2282     c_result = (unsigned int)jresult;
2283   }
2284   return c_result;
2285 }
2286
2287 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2288   Dali::Actor c_result ;
2289   void * jresult = 0 ;
2290   unsigned int jitemId  ;
2291
2292   if (!swig_callbackNewItem) {
2293     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2294   } else {
2295     jitemId = itemId;
2296     jresult = (void *) swig_callbackNewItem(jitemId);
2297     if (!jresult) {
2298       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2299       return c_result;
2300     }
2301     c_result = *(Dali::Actor *)jresult;
2302   }
2303   return c_result;
2304 }
2305
2306 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2307   unsigned int jitemId  ;
2308   void * jactor  ;
2309
2310   if (!swig_callbackItemReleased) {
2311     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2312     return;
2313   } else {
2314     jitemId = itemId;
2315     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2316     swig_callbackItemReleased(jitemId, jactor);
2317   }
2318 }
2319
2320 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2321   return Dali::Toolkit::ItemFactory::GetExtension();
2322 }
2323
2324 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2325   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2326   swig_callbackNewItem = callbackNewItem;
2327   swig_callbackItemReleased = callbackItemReleased;
2328 }
2329
2330 void SwigDirector_ItemFactory::swig_init_callbacks() {
2331   swig_callbackGetNumberOfItems = 0;
2332   swig_callbackNewItem = 0;
2333   swig_callbackItemReleased = 0;
2334 }
2335
2336 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2337   swig_init_callbacks();
2338 }
2339
2340 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2341
2342 }
2343
2344
2345 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2346   Dali::Actor c_result ;
2347   void * jresult = 0 ;
2348   void * jcurrent  ;
2349   void * jproposed  ;
2350   int jdirection  ;
2351
2352   if (!swig_callbackGetNextFocusableActor) {
2353     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2354   } else {
2355     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2356     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2357     jdirection = (int)direction;
2358     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2359     if (!jresult) {
2360       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2361       return c_result;
2362     }
2363     c_result = *(Dali::Actor *)jresult;
2364   }
2365   return c_result;
2366 }
2367
2368 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2369   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2370 }
2371
2372 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2373   swig_callbackGetNextFocusableActor = 0;
2374 }
2375
2376
2377 #ifdef __cplusplus
2378 extern "C" {
2379 #endif
2380
2381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2382   void * jresult ;
2383   floatp *result = 0 ;
2384
2385   {
2386     try {
2387       result = (floatp *)new_floatp();
2388     } catch (std::out_of_range& e) {
2389       {
2390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2391       };
2392     } catch (std::exception& e) {
2393       {
2394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2395       };
2396     } catch (...) {
2397       {
2398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2399       };
2400     }
2401   }
2402   jresult = (void *)result;
2403   return jresult;
2404 }
2405
2406
2407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2408   floatp *arg1 = (floatp *) 0 ;
2409
2410   arg1 = (floatp *)jarg1;
2411   {
2412     try {
2413       delete_floatp(arg1);
2414     } catch (std::out_of_range& e) {
2415       {
2416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2417       };
2418     } catch (std::exception& e) {
2419       {
2420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2421       };
2422     } catch (...) {
2423       {
2424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2425       };
2426     }
2427   }
2428 }
2429
2430
2431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2432   floatp *arg1 = (floatp *) 0 ;
2433   float arg2 ;
2434
2435   arg1 = (floatp *)jarg1;
2436   arg2 = (float)jarg2;
2437   {
2438     try {
2439       floatp_assign(arg1,arg2);
2440     } catch (std::out_of_range& e) {
2441       {
2442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2443       };
2444     } catch (std::exception& e) {
2445       {
2446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2447       };
2448     } catch (...) {
2449       {
2450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2451       };
2452     }
2453   }
2454 }
2455
2456
2457 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2458   float jresult ;
2459   floatp *arg1 = (floatp *) 0 ;
2460   float result;
2461
2462   arg1 = (floatp *)jarg1;
2463   {
2464     try {
2465       result = (float)floatp_value(arg1);
2466     } catch (std::out_of_range& e) {
2467       {
2468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2469       };
2470     } catch (std::exception& e) {
2471       {
2472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2473       };
2474     } catch (...) {
2475       {
2476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2477       };
2478     }
2479   }
2480   jresult = result;
2481   return jresult;
2482 }
2483
2484
2485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2486   void * jresult ;
2487   floatp *arg1 = (floatp *) 0 ;
2488   float *result = 0 ;
2489
2490   arg1 = (floatp *)jarg1;
2491   {
2492     try {
2493       result = (float *)floatp_cast(arg1);
2494     } catch (std::out_of_range& e) {
2495       {
2496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2497       };
2498     } catch (std::exception& e) {
2499       {
2500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2501       };
2502     } catch (...) {
2503       {
2504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2505       };
2506     }
2507   }
2508   jresult = (void *)result;
2509   return jresult;
2510 }
2511
2512
2513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2514   void * jresult ;
2515   float *arg1 = (float *) 0 ;
2516   floatp *result = 0 ;
2517
2518   arg1 = (float *)jarg1;
2519   {
2520     try {
2521       result = (floatp *)floatp_frompointer(arg1);
2522     } catch (std::out_of_range& e) {
2523       {
2524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2525       };
2526     } catch (std::exception& e) {
2527       {
2528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2529       };
2530     } catch (...) {
2531       {
2532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2533       };
2534     }
2535   }
2536   jresult = (void *)result;
2537   return jresult;
2538 }
2539
2540
2541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2542   void * jresult ;
2543   intp *result = 0 ;
2544
2545   {
2546     try {
2547       result = (intp *)new_intp();
2548     } catch (std::out_of_range& e) {
2549       {
2550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (std::exception& e) {
2553       {
2554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (...) {
2557       {
2558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2559       };
2560     }
2561   }
2562   jresult = (void *)result;
2563   return jresult;
2564 }
2565
2566
2567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2568   intp *arg1 = (intp *) 0 ;
2569
2570   arg1 = (intp *)jarg1;
2571   {
2572     try {
2573       delete_intp(arg1);
2574     } catch (std::out_of_range& e) {
2575       {
2576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2577       };
2578     } catch (std::exception& e) {
2579       {
2580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2581       };
2582     } catch (...) {
2583       {
2584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2585       };
2586     }
2587   }
2588 }
2589
2590
2591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2592   intp *arg1 = (intp *) 0 ;
2593   int arg2 ;
2594
2595   arg1 = (intp *)jarg1;
2596   arg2 = (int)jarg2;
2597   {
2598     try {
2599       intp_assign(arg1,arg2);
2600     } catch (std::out_of_range& e) {
2601       {
2602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2603       };
2604     } catch (std::exception& e) {
2605       {
2606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2611       };
2612     }
2613   }
2614 }
2615
2616
2617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2618   int jresult ;
2619   intp *arg1 = (intp *) 0 ;
2620   int result;
2621
2622   arg1 = (intp *)jarg1;
2623   {
2624     try {
2625       result = (int)intp_value(arg1);
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2633       };
2634     } catch (...) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2637       };
2638     }
2639   }
2640   jresult = result;
2641   return jresult;
2642 }
2643
2644
2645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2646   void * jresult ;
2647   intp *arg1 = (intp *) 0 ;
2648   int *result = 0 ;
2649
2650   arg1 = (intp *)jarg1;
2651   {
2652     try {
2653       result = (int *)intp_cast(arg1);
2654     } catch (std::out_of_range& e) {
2655       {
2656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2657       };
2658     } catch (std::exception& e) {
2659       {
2660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2661       };
2662     } catch (...) {
2663       {
2664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2665       };
2666     }
2667   }
2668   jresult = (void *)result;
2669   return jresult;
2670 }
2671
2672
2673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2674   void * jresult ;
2675   int *arg1 = (int *) 0 ;
2676   intp *result = 0 ;
2677
2678   arg1 = (int *)jarg1;
2679   {
2680     try {
2681       result = (intp *)intp_frompointer(arg1);
2682     } catch (std::out_of_range& e) {
2683       {
2684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2685       };
2686     } catch (std::exception& e) {
2687       {
2688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2693       };
2694     }
2695   }
2696   jresult = (void *)result;
2697   return jresult;
2698 }
2699
2700
2701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2702   void * jresult ;
2703   doublep *result = 0 ;
2704
2705   {
2706     try {
2707       result = (doublep *)new_doublep();
2708     } catch (std::out_of_range& e) {
2709       {
2710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2711       };
2712     } catch (std::exception& e) {
2713       {
2714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2715       };
2716     } catch (...) {
2717       {
2718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2719       };
2720     }
2721   }
2722   jresult = (void *)result;
2723   return jresult;
2724 }
2725
2726
2727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2728   doublep *arg1 = (doublep *) 0 ;
2729
2730   arg1 = (doublep *)jarg1;
2731   {
2732     try {
2733       delete_doublep(arg1);
2734     } catch (std::out_of_range& e) {
2735       {
2736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2737       };
2738     } catch (std::exception& e) {
2739       {
2740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2741       };
2742     } catch (...) {
2743       {
2744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2745       };
2746     }
2747   }
2748 }
2749
2750
2751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2752   doublep *arg1 = (doublep *) 0 ;
2753   double arg2 ;
2754
2755   arg1 = (doublep *)jarg1;
2756   arg2 = (double)jarg2;
2757   {
2758     try {
2759       doublep_assign(arg1,arg2);
2760     } catch (std::out_of_range& e) {
2761       {
2762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2763       };
2764     } catch (std::exception& e) {
2765       {
2766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2771       };
2772     }
2773   }
2774 }
2775
2776
2777 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2778   double jresult ;
2779   doublep *arg1 = (doublep *) 0 ;
2780   double result;
2781
2782   arg1 = (doublep *)jarg1;
2783   {
2784     try {
2785       result = (double)doublep_value(arg1);
2786     } catch (std::out_of_range& e) {
2787       {
2788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (std::exception& e) {
2791       {
2792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (...) {
2795       {
2796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2797       };
2798     }
2799   }
2800   jresult = result;
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2806   void * jresult ;
2807   doublep *arg1 = (doublep *) 0 ;
2808   double *result = 0 ;
2809
2810   arg1 = (doublep *)jarg1;
2811   {
2812     try {
2813       result = (double *)doublep_cast(arg1);
2814     } catch (std::out_of_range& e) {
2815       {
2816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2817       };
2818     } catch (std::exception& e) {
2819       {
2820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2821       };
2822     } catch (...) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2825       };
2826     }
2827   }
2828   jresult = (void *)result;
2829   return jresult;
2830 }
2831
2832
2833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2834   void * jresult ;
2835   double *arg1 = (double *) 0 ;
2836   doublep *result = 0 ;
2837
2838   arg1 = (double *)jarg1;
2839   {
2840     try {
2841       result = (doublep *)doublep_frompointer(arg1);
2842     } catch (std::out_of_range& e) {
2843       {
2844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2845       };
2846     } catch (std::exception& e) {
2847       {
2848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2849       };
2850     } catch (...) {
2851       {
2852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2853       };
2854     }
2855   }
2856   jresult = (void *)result;
2857   return jresult;
2858 }
2859
2860
2861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2862   void * jresult ;
2863   uintp *result = 0 ;
2864
2865   {
2866     try {
2867       result = (uintp *)new_uintp();
2868     } catch (std::out_of_range& e) {
2869       {
2870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (std::exception& e) {
2873       {
2874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882   jresult = (void *)result;
2883   return jresult;
2884 }
2885
2886
2887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2888   uintp *arg1 = (uintp *) 0 ;
2889
2890   arg1 = (uintp *)jarg1;
2891   {
2892     try {
2893       delete_uintp(arg1);
2894     } catch (std::out_of_range& e) {
2895       {
2896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2897       };
2898     } catch (std::exception& e) {
2899       {
2900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2901       };
2902     } catch (...) {
2903       {
2904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2905       };
2906     }
2907   }
2908 }
2909
2910
2911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2912   uintp *arg1 = (uintp *) 0 ;
2913   unsigned int arg2 ;
2914
2915   arg1 = (uintp *)jarg1;
2916   arg2 = (unsigned int)jarg2;
2917   {
2918     try {
2919       uintp_assign(arg1,arg2);
2920     } catch (std::out_of_range& e) {
2921       {
2922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2923       };
2924     } catch (std::exception& e) {
2925       {
2926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2927       };
2928     } catch (...) {
2929       {
2930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2931       };
2932     }
2933   }
2934 }
2935
2936
2937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2938   unsigned int jresult ;
2939   uintp *arg1 = (uintp *) 0 ;
2940   unsigned int result;
2941
2942   arg1 = (uintp *)jarg1;
2943   {
2944     try {
2945       result = (unsigned int)uintp_value(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (...) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2957       };
2958     }
2959   }
2960   jresult = result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2966   void * jresult ;
2967   uintp *arg1 = (uintp *) 0 ;
2968   unsigned int *result = 0 ;
2969
2970   arg1 = (uintp *)jarg1;
2971   {
2972     try {
2973       result = (unsigned int *)uintp_cast(arg1);
2974     } catch (std::out_of_range& e) {
2975       {
2976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2977       };
2978     } catch (std::exception& e) {
2979       {
2980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2981       };
2982     } catch (...) {
2983       {
2984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2985       };
2986     }
2987   }
2988   jresult = (void *)result;
2989   return jresult;
2990 }
2991
2992
2993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2994   void * jresult ;
2995   unsigned int *arg1 = (unsigned int *) 0 ;
2996   uintp *result = 0 ;
2997
2998   arg1 = (unsigned int *)jarg1;
2999   {
3000     try {
3001       result = (uintp *)uintp_frompointer(arg1);
3002     } catch (std::out_of_range& e) {
3003       {
3004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3005       };
3006     } catch (std::exception& e) {
3007       {
3008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3009       };
3010     } catch (...) {
3011       {
3012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3013       };
3014     }
3015   }
3016   jresult = (void *)result;
3017   return jresult;
3018 }
3019
3020
3021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3022   void * jresult ;
3023   ushortp *result = 0 ;
3024
3025   {
3026     try {
3027       result = (ushortp *)new_ushortp();
3028     } catch (std::out_of_range& e) {
3029       {
3030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3031       };
3032     } catch (std::exception& e) {
3033       {
3034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3035       };
3036     } catch (...) {
3037       {
3038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3039       };
3040     }
3041   }
3042   jresult = (void *)result;
3043   return jresult;
3044 }
3045
3046
3047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3048   ushortp *arg1 = (ushortp *) 0 ;
3049
3050   arg1 = (ushortp *)jarg1;
3051   {
3052     try {
3053       delete_ushortp(arg1);
3054     } catch (std::out_of_range& e) {
3055       {
3056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3057       };
3058     } catch (std::exception& e) {
3059       {
3060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3061       };
3062     } catch (...) {
3063       {
3064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3065       };
3066     }
3067   }
3068 }
3069
3070
3071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3072   ushortp *arg1 = (ushortp *) 0 ;
3073   unsigned short arg2 ;
3074
3075   arg1 = (ushortp *)jarg1;
3076   arg2 = (unsigned short)jarg2;
3077   {
3078     try {
3079       ushortp_assign(arg1,arg2);
3080     } catch (std::out_of_range& e) {
3081       {
3082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3083       };
3084     } catch (std::exception& e) {
3085       {
3086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3087       };
3088     } catch (...) {
3089       {
3090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3091       };
3092     }
3093   }
3094 }
3095
3096
3097 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3098   unsigned short jresult ;
3099   ushortp *arg1 = (ushortp *) 0 ;
3100   unsigned short result;
3101
3102   arg1 = (ushortp *)jarg1;
3103   {
3104     try {
3105       result = (unsigned short)ushortp_value(arg1);
3106     } catch (std::out_of_range& e) {
3107       {
3108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3109       };
3110     } catch (std::exception& e) {
3111       {
3112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (...) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3117       };
3118     }
3119   }
3120   jresult = result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3126   void * jresult ;
3127   ushortp *arg1 = (ushortp *) 0 ;
3128   unsigned short *result = 0 ;
3129
3130   arg1 = (ushortp *)jarg1;
3131   {
3132     try {
3133       result = (unsigned short *)ushortp_cast(arg1);
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (...) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3145       };
3146     }
3147   }
3148   jresult = (void *)result;
3149   return jresult;
3150 }
3151
3152
3153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3154   void * jresult ;
3155   unsigned short *arg1 = (unsigned short *) 0 ;
3156   ushortp *result = 0 ;
3157
3158   arg1 = (unsigned short *)jarg1;
3159   {
3160     try {
3161       result = (ushortp *)ushortp_frompointer(arg1);
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3169       };
3170     } catch (...) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3173       };
3174     }
3175   }
3176   jresult = (void *)result;
3177   return jresult;
3178 }
3179
3180
3181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3182   unsigned int jresult ;
3183   int arg1 ;
3184   unsigned int result;
3185
3186   arg1 = (int)jarg1;
3187   {
3188     try {
3189       result = (unsigned int)int_to_uint(arg1);
3190     } catch (std::out_of_range& e) {
3191       {
3192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3193       };
3194     } catch (std::exception& e) {
3195       {
3196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3197       };
3198     } catch (...) {
3199       {
3200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3201       };
3202     }
3203   }
3204   jresult = result;
3205   return jresult;
3206 }
3207
3208
3209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3210   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3211
3212   arg1 = (Dali::RefObject *)jarg1;
3213   {
3214     try {
3215       (arg1)->Reference();
3216     } catch (std::out_of_range& e) {
3217       {
3218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3219       };
3220     } catch (std::exception& e) {
3221       {
3222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3223       };
3224     } catch (...) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3227       };
3228     }
3229   }
3230 }
3231
3232
3233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3234   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3235
3236   arg1 = (Dali::RefObject *)jarg1;
3237   {
3238     try {
3239       (arg1)->Unreference();
3240     } catch (std::out_of_range& e) {
3241       {
3242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3243       };
3244     } catch (std::exception& e) {
3245       {
3246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3247       };
3248     } catch (...) {
3249       {
3250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3251       };
3252     }
3253   }
3254 }
3255
3256
3257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3258   int jresult ;
3259   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3260   int result;
3261
3262   arg1 = (Dali::RefObject *)jarg1;
3263   {
3264     try {
3265       result = (int)(arg1)->ReferenceCount();
3266     } catch (std::out_of_range& e) {
3267       {
3268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3269       };
3270     } catch (std::exception& e) {
3271       {
3272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3273       };
3274     } catch (...) {
3275       {
3276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3277       };
3278     }
3279   }
3280   jresult = result;
3281   return jresult;
3282 }
3283
3284
3285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3286   void * jresult ;
3287   Dali::Any *result = 0 ;
3288
3289   {
3290     try {
3291       result = (Dali::Any *)new Dali::Any();
3292     } catch (std::out_of_range& e) {
3293       {
3294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3295       };
3296     } catch (std::exception& e) {
3297       {
3298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (...) {
3301       {
3302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3303       };
3304     }
3305   }
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3312   Dali::Any *arg1 = (Dali::Any *) 0 ;
3313
3314   arg1 = (Dali::Any *)jarg1;
3315   {
3316     try {
3317       delete arg1;
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (...) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3329       };
3330     }
3331   }
3332 }
3333
3334
3335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3336   char *arg1 = (char *) 0 ;
3337
3338   arg1 = (char *)jarg1;
3339   {
3340     try {
3341       Dali::Any::AssertAlways((char const *)arg1);
3342     } catch (std::out_of_range& e) {
3343       {
3344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (std::exception& e) {
3347       {
3348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3349       };
3350     } catch (...) {
3351       {
3352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3353       };
3354     }
3355   }
3356 }
3357
3358
3359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3360   void * jresult ;
3361   Dali::Any *arg1 = 0 ;
3362   Dali::Any *result = 0 ;
3363
3364   arg1 = (Dali::Any *)jarg1;
3365   if (!arg1) {
3366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3367     return 0;
3368   }
3369   {
3370     try {
3371       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3372     } catch (std::out_of_range& e) {
3373       {
3374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3375       };
3376     } catch (std::exception& e) {
3377       {
3378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3379       };
3380     } catch (...) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3383       };
3384     }
3385   }
3386   jresult = (void *)result;
3387   return jresult;
3388 }
3389
3390
3391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3392   void * jresult ;
3393   Dali::Any *arg1 = (Dali::Any *) 0 ;
3394   Dali::Any *arg2 = 0 ;
3395   Dali::Any *result = 0 ;
3396
3397   arg1 = (Dali::Any *)jarg1;
3398   arg2 = (Dali::Any *)jarg2;
3399   if (!arg2) {
3400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3401     return 0;
3402   }
3403   {
3404     try {
3405       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3406     } catch (std::out_of_range& e) {
3407       {
3408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3409       };
3410     } catch (std::exception& e) {
3411       {
3412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3413       };
3414     } catch (...) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3417       };
3418     }
3419   }
3420   jresult = (void *)result;
3421   return jresult;
3422 }
3423
3424
3425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3426   void * jresult ;
3427   Dali::Any *arg1 = (Dali::Any *) 0 ;
3428   std::type_info *result = 0 ;
3429
3430   arg1 = (Dali::Any *)jarg1;
3431   {
3432     try {
3433       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3434     } catch (std::out_of_range& e) {
3435       {
3436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3437       };
3438     } catch (std::exception& e) {
3439       {
3440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3441       };
3442     } catch (...) {
3443       {
3444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3445       };
3446     }
3447   }
3448   jresult = (void *)result;
3449   return jresult;
3450 }
3451
3452
3453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3454   unsigned int jresult ;
3455   Dali::Any *arg1 = (Dali::Any *) 0 ;
3456   bool result;
3457
3458   arg1 = (Dali::Any *)jarg1;
3459   {
3460     try {
3461       result = (bool)((Dali::Any const *)arg1)->Empty();
3462     } catch (std::out_of_range& e) {
3463       {
3464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3465       };
3466     } catch (std::exception& e) {
3467       {
3468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3469       };
3470     } catch (...) {
3471       {
3472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3473       };
3474     }
3475   }
3476   jresult = result;
3477   return jresult;
3478 }
3479
3480
3481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3482   void * jresult ;
3483   std::type_info *arg1 = 0 ;
3484   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3485   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3486   Dali::Any::AnyContainerBase *result = 0 ;
3487
3488   arg1 = (std::type_info *)jarg1;
3489   if (!arg1) {
3490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3491     return 0;
3492   }
3493   arg2 = (Dali::Any::CloneFunc)jarg2;
3494   arg3 = (Dali::Any::DeleteFunc)jarg3;
3495   {
3496     try {
3497       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3498     } catch (std::out_of_range& e) {
3499       {
3500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3501       };
3502     } catch (std::exception& e) {
3503       {
3504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (...) {
3507       {
3508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3509       };
3510     }
3511   }
3512   jresult = (void *)result;
3513   return jresult;
3514 }
3515
3516
3517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3518   void * jresult ;
3519   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3520   std::type_info *result = 0 ;
3521
3522   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3523   {
3524     try {
3525       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3526     } catch (std::out_of_range& e) {
3527       {
3528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3529       };
3530     } catch (std::exception& e) {
3531       {
3532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3533       };
3534     } catch (...) {
3535       {
3536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3537       };
3538     }
3539   }
3540   jresult = (void *)result;
3541   return jresult;
3542 }
3543
3544
3545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3546   void * jresult ;
3547   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3548   ::std::type_info *result = 0 ;
3549
3550   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3551   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3552   jresult = (void *)result;
3553   return jresult;
3554 }
3555
3556
3557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3558   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3559   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3560
3561   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3562   arg2 = (Dali::Any::CloneFunc)jarg2;
3563   if (arg1) (arg1)->mCloneFunc = arg2;
3564 }
3565
3566
3567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3568   void * jresult ;
3569   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3570   Dali::Any::CloneFunc result;
3571
3572   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3573   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3574   jresult = (void *)result;
3575   return jresult;
3576 }
3577
3578
3579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3580   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3581   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3582
3583   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3584   arg2 = (Dali::Any::DeleteFunc)jarg2;
3585   if (arg1) (arg1)->mDeleteFunc = arg2;
3586 }
3587
3588
3589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3590   void * jresult ;
3591   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3592   Dali::Any::DeleteFunc result;
3593
3594   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3595   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3596   jresult = (void *)result;
3597   return jresult;
3598 }
3599
3600
3601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3602   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3603
3604   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3605   {
3606     try {
3607       delete arg1;
3608     } catch (std::out_of_range& e) {
3609       {
3610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3611       };
3612     } catch (std::exception& e) {
3613       {
3614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3615       };
3616     } catch (...) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3619       };
3620     }
3621   }
3622 }
3623
3624
3625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3626   Dali::Any *arg1 = (Dali::Any *) 0 ;
3627   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3628
3629   arg1 = (Dali::Any *)jarg1;
3630   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3631   if (arg1) (arg1)->mContainer = arg2;
3632 }
3633
3634
3635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3636   void * jresult ;
3637   Dali::Any *arg1 = (Dali::Any *) 0 ;
3638   Dali::Any::AnyContainerBase *result = 0 ;
3639
3640   arg1 = (Dali::Any *)jarg1;
3641   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3642   jresult = (void *)result;
3643   return jresult;
3644 }
3645
3646
3647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3648   char *arg1 = (char *) 0 ;
3649   char *arg2 = (char *) 0 ;
3650
3651   arg1 = (char *)jarg1;
3652   arg2 = (char *)jarg2;
3653   {
3654     try {
3655       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3656     } catch (std::out_of_range& e) {
3657       {
3658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3659       };
3660     } catch (std::exception& e) {
3661       {
3662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3663       };
3664     } catch (...) {
3665       {
3666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3667       };
3668     }
3669   }
3670 }
3671
3672
3673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3674   void * jresult ;
3675   char *arg1 = (char *) 0 ;
3676   char *arg2 = (char *) 0 ;
3677   Dali::DaliException *result = 0 ;
3678
3679   arg1 = (char *)jarg1;
3680   arg2 = (char *)jarg2;
3681   {
3682     try {
3683       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3684     } catch (std::out_of_range& e) {
3685       {
3686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3687       };
3688     } catch (std::exception& e) {
3689       {
3690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3691       };
3692     } catch (...) {
3693       {
3694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3695       };
3696     }
3697   }
3698   jresult = (void *)result;
3699   return jresult;
3700 }
3701
3702
3703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3704   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3705   char *arg2 = (char *) 0 ;
3706
3707   arg1 = (Dali::DaliException *)jarg1;
3708   arg2 = (char *)jarg2;
3709   {
3710     if (arg2) {
3711       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3712       strcpy((char *)arg1->location, (const char *)arg2);
3713     } else {
3714       arg1->location = 0;
3715     }
3716   }
3717 }
3718
3719
3720 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3721   char * jresult ;
3722   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3723   char *result = 0 ;
3724
3725   arg1 = (Dali::DaliException *)jarg1;
3726   result = (char *) ((arg1)->location);
3727   jresult = SWIG_csharp_string_callback((const char *)result);
3728   return jresult;
3729 }
3730
3731
3732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3733   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3734   char *arg2 = (char *) 0 ;
3735
3736   arg1 = (Dali::DaliException *)jarg1;
3737   arg2 = (char *)jarg2;
3738   {
3739     if (arg2) {
3740       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3741       strcpy((char *)arg1->condition, (const char *)arg2);
3742     } else {
3743       arg1->condition = 0;
3744     }
3745   }
3746 }
3747
3748
3749 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3750   char * jresult ;
3751   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3752   char *result = 0 ;
3753
3754   arg1 = (Dali::DaliException *)jarg1;
3755   result = (char *) ((arg1)->condition);
3756   jresult = SWIG_csharp_string_callback((const char *)result);
3757   return jresult;
3758 }
3759
3760
3761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3762   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3763
3764   arg1 = (Dali::DaliException *)jarg1;
3765   {
3766     try {
3767       delete arg1;
3768     } catch (std::out_of_range& e) {
3769       {
3770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3771       };
3772     } catch (std::exception& e) {
3773       {
3774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3775       };
3776     } catch (...) {
3777       {
3778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3779       };
3780     }
3781   }
3782 }
3783
3784
3785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3786   void * jresult ;
3787   Dali::Vector2 *result = 0 ;
3788
3789   {
3790     try {
3791       result = (Dali::Vector2 *)new Dali::Vector2();
3792     } catch (std::out_of_range& e) {
3793       {
3794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3795       };
3796     } catch (std::exception& e) {
3797       {
3798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3799       };
3800     } catch (...) {
3801       {
3802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3803       };
3804     }
3805   }
3806   jresult = (void *)result;
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3812   void * jresult ;
3813   float arg1 ;
3814   float arg2 ;
3815   Dali::Vector2 *result = 0 ;
3816
3817   arg1 = (float)jarg1;
3818   arg2 = (float)jarg2;
3819   {
3820     try {
3821       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3822     } catch (std::out_of_range& e) {
3823       {
3824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3825       };
3826     } catch (std::exception& e) {
3827       {
3828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3829       };
3830     } catch (...) {
3831       {
3832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3833       };
3834     }
3835   }
3836   jresult = (void *)result;
3837   return jresult;
3838 }
3839
3840
3841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3842   void * jresult ;
3843   float *arg1 = (float *) 0 ;
3844   Dali::Vector2 *result = 0 ;
3845
3846   arg1 = jarg1;
3847   {
3848     try {
3849       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3850     } catch (std::out_of_range& e) {
3851       {
3852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3853       };
3854     } catch (std::exception& e) {
3855       {
3856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3857       };
3858     } catch (...) {
3859       {
3860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3861       };
3862     }
3863   }
3864   jresult = (void *)result;
3865
3866
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3872   void * jresult ;
3873   Dali::Vector3 *arg1 = 0 ;
3874   Dali::Vector2 *result = 0 ;
3875
3876   arg1 = (Dali::Vector3 *)jarg1;
3877   if (!arg1) {
3878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3879     return 0;
3880   }
3881   {
3882     try {
3883       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3884     } catch (std::out_of_range& e) {
3885       {
3886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3887       };
3888     } catch (std::exception& e) {
3889       {
3890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3891       };
3892     } catch (...) {
3893       {
3894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3895       };
3896     }
3897   }
3898   jresult = (void *)result;
3899   return jresult;
3900 }
3901
3902
3903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3904   void * jresult ;
3905   Dali::Vector4 *arg1 = 0 ;
3906   Dali::Vector2 *result = 0 ;
3907
3908   arg1 = (Dali::Vector4 *)jarg1;
3909   if (!arg1) {
3910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3911     return 0;
3912   }
3913   {
3914     try {
3915       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3916     } catch (std::out_of_range& e) {
3917       {
3918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (std::exception& e) {
3921       {
3922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930   jresult = (void *)result;
3931   return jresult;
3932 }
3933
3934
3935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3936   void * jresult ;
3937   Dali::Vector2 *result = 0 ;
3938
3939   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3940   jresult = (void *)result;
3941   return jresult;
3942 }
3943
3944
3945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3946   void * jresult ;
3947   Dali::Vector2 *result = 0 ;
3948
3949   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3950   jresult = (void *)result;
3951   return jresult;
3952 }
3953
3954
3955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3956   void * jresult ;
3957   Dali::Vector2 *result = 0 ;
3958
3959   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3960   jresult = (void *)result;
3961   return jresult;
3962 }
3963
3964
3965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3966   void * jresult ;
3967   Dali::Vector2 *result = 0 ;
3968
3969   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3970   jresult = (void *)result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3976   void * jresult ;
3977   Dali::Vector2 *result = 0 ;
3978
3979   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3980   jresult = (void *)result;
3981   return jresult;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3986   void * jresult ;
3987   Dali::Vector2 *result = 0 ;
3988
3989   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3990   jresult = (void *)result;
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3996   void * jresult ;
3997   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3998   float *arg2 = (float *) 0 ;
3999   Dali::Vector2 *result = 0 ;
4000
4001   arg1 = (Dali::Vector2 *)jarg1;
4002   arg2 = jarg2;
4003   {
4004     try {
4005       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4006     } catch (std::out_of_range& e) {
4007       {
4008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4009       };
4010     } catch (std::exception& e) {
4011       {
4012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4013       };
4014     } catch (...) {
4015       {
4016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4017       };
4018     }
4019   }
4020   jresult = (void *)result;
4021
4022
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4028   void * jresult ;
4029   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4030   Dali::Vector3 *arg2 = 0 ;
4031   Dali::Vector2 *result = 0 ;
4032
4033   arg1 = (Dali::Vector2 *)jarg1;
4034   arg2 = (Dali::Vector3 *)jarg2;
4035   if (!arg2) {
4036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4037     return 0;
4038   }
4039   {
4040     try {
4041       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4042     } catch (std::out_of_range& e) {
4043       {
4044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4045       };
4046     } catch (std::exception& e) {
4047       {
4048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4049       };
4050     } catch (...) {
4051       {
4052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4053       };
4054     }
4055   }
4056   jresult = (void *)result;
4057   return jresult;
4058 }
4059
4060
4061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4062   void * jresult ;
4063   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4064   Dali::Vector4 *arg2 = 0 ;
4065   Dali::Vector2 *result = 0 ;
4066
4067   arg1 = (Dali::Vector2 *)jarg1;
4068   arg2 = (Dali::Vector4 *)jarg2;
4069   if (!arg2) {
4070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4071     return 0;
4072   }
4073   {
4074     try {
4075       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4076     } catch (std::out_of_range& e) {
4077       {
4078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4079       };
4080     } catch (std::exception& e) {
4081       {
4082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4083       };
4084     } catch (...) {
4085       {
4086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4087       };
4088     }
4089   }
4090   jresult = (void *)result;
4091   return jresult;
4092 }
4093
4094
4095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4096   void * jresult ;
4097   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4098   Dali::Vector2 *arg2 = 0 ;
4099   Dali::Vector2 result;
4100
4101   arg1 = (Dali::Vector2 *)jarg1;
4102   arg2 = (Dali::Vector2 *)jarg2;
4103   if (!arg2) {
4104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4105     return 0;
4106   }
4107   {
4108     try {
4109       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4110     } catch (std::out_of_range& e) {
4111       {
4112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (std::exception& e) {
4115       {
4116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4117       };
4118     } catch (...) {
4119       {
4120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4121       };
4122     }
4123   }
4124   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4130   void * jresult ;
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   Dali::Vector2 *arg2 = 0 ;
4133   Dali::Vector2 *result = 0 ;
4134
4135   arg1 = (Dali::Vector2 *)jarg1;
4136   arg2 = (Dali::Vector2 *)jarg2;
4137   if (!arg2) {
4138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4139     return 0;
4140   }
4141   {
4142     try {
4143       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4144     } catch (std::out_of_range& e) {
4145       {
4146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4147       };
4148     } catch (std::exception& e) {
4149       {
4150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4151       };
4152     } catch (...) {
4153       {
4154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4155       };
4156     }
4157   }
4158   jresult = (void *)result;
4159   return jresult;
4160 }
4161
4162
4163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4164   void * jresult ;
4165   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4166   Dali::Vector2 *arg2 = 0 ;
4167   Dali::Vector2 result;
4168
4169   arg1 = (Dali::Vector2 *)jarg1;
4170   arg2 = (Dali::Vector2 *)jarg2;
4171   if (!arg2) {
4172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4173     return 0;
4174   }
4175   {
4176     try {
4177       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4178     } catch (std::out_of_range& e) {
4179       {
4180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4181       };
4182     } catch (std::exception& e) {
4183       {
4184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (...) {
4187       {
4188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4189       };
4190     }
4191   }
4192   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4193   return jresult;
4194 }
4195
4196
4197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4198   void * jresult ;
4199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4200   Dali::Vector2 *arg2 = 0 ;
4201   Dali::Vector2 *result = 0 ;
4202
4203   arg1 = (Dali::Vector2 *)jarg1;
4204   arg2 = (Dali::Vector2 *)jarg2;
4205   if (!arg2) {
4206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4207     return 0;
4208   }
4209   {
4210     try {
4211       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4212     } catch (std::out_of_range& e) {
4213       {
4214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4215       };
4216     } catch (std::exception& e) {
4217       {
4218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4219       };
4220     } catch (...) {
4221       {
4222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4223       };
4224     }
4225   }
4226   jresult = (void *)result;
4227   return jresult;
4228 }
4229
4230
4231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4232   void * jresult ;
4233   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4234   Dali::Vector2 *arg2 = 0 ;
4235   Dali::Vector2 result;
4236
4237   arg1 = (Dali::Vector2 *)jarg1;
4238   arg2 = (Dali::Vector2 *)jarg2;
4239   if (!arg2) {
4240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4241     return 0;
4242   }
4243   {
4244     try {
4245       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4246     } catch (std::out_of_range& e) {
4247       {
4248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (std::exception& e) {
4251       {
4252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (...) {
4255       {
4256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4257       };
4258     }
4259   }
4260   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4261   return jresult;
4262 }
4263
4264
4265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4266   void * jresult ;
4267   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4268   float arg2 ;
4269   Dali::Vector2 result;
4270
4271   arg1 = (Dali::Vector2 *)jarg1;
4272   arg2 = (float)jarg2;
4273   {
4274     try {
4275       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4276     } catch (std::out_of_range& e) {
4277       {
4278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4279       };
4280     } catch (std::exception& e) {
4281       {
4282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4283       };
4284     } catch (...) {
4285       {
4286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4287       };
4288     }
4289   }
4290   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4291   return jresult;
4292 }
4293
4294
4295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4296   void * jresult ;
4297   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4298   Dali::Vector2 *arg2 = 0 ;
4299   Dali::Vector2 *result = 0 ;
4300
4301   arg1 = (Dali::Vector2 *)jarg1;
4302   arg2 = (Dali::Vector2 *)jarg2;
4303   if (!arg2) {
4304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4305     return 0;
4306   }
4307   {
4308     try {
4309       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4310     } catch (std::out_of_range& e) {
4311       {
4312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4313       };
4314     } catch (std::exception& e) {
4315       {
4316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (...) {
4319       {
4320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4321       };
4322     }
4323   }
4324   jresult = (void *)result;
4325   return jresult;
4326 }
4327
4328
4329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4330   void * jresult ;
4331   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4332   float arg2 ;
4333   Dali::Vector2 *result = 0 ;
4334
4335   arg1 = (Dali::Vector2 *)jarg1;
4336   arg2 = (float)jarg2;
4337   {
4338     try {
4339       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4340     } catch (std::out_of_range& e) {
4341       {
4342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (std::exception& e) {
4345       {
4346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354   jresult = (void *)result;
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4360   void * jresult ;
4361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4362   Dali::Vector2 *arg2 = 0 ;
4363   Dali::Vector2 result;
4364
4365   arg1 = (Dali::Vector2 *)jarg1;
4366   arg2 = (Dali::Vector2 *)jarg2;
4367   if (!arg2) {
4368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4369     return 0;
4370   }
4371   {
4372     try {
4373       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4374     } catch (std::out_of_range& e) {
4375       {
4376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4377       };
4378     } catch (std::exception& e) {
4379       {
4380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (...) {
4383       {
4384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4385       };
4386     }
4387   }
4388   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4394   void * jresult ;
4395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4396   float arg2 ;
4397   Dali::Vector2 result;
4398
4399   arg1 = (Dali::Vector2 *)jarg1;
4400   arg2 = (float)jarg2;
4401   {
4402     try {
4403       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4404     } catch (std::out_of_range& e) {
4405       {
4406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4407       };
4408     } catch (std::exception& e) {
4409       {
4410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4411       };
4412     } catch (...) {
4413       {
4414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4415       };
4416     }
4417   }
4418   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4424   void * jresult ;
4425   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4426   Dali::Vector2 *arg2 = 0 ;
4427   Dali::Vector2 *result = 0 ;
4428
4429   arg1 = (Dali::Vector2 *)jarg1;
4430   arg2 = (Dali::Vector2 *)jarg2;
4431   if (!arg2) {
4432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4433     return 0;
4434   }
4435   {
4436     try {
4437       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4438     } catch (std::out_of_range& e) {
4439       {
4440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4441       };
4442     } catch (std::exception& e) {
4443       {
4444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4445       };
4446     } catch (...) {
4447       {
4448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4449       };
4450     }
4451   }
4452   jresult = (void *)result;
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float arg2 ;
4461   Dali::Vector2 *result = 0 ;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = (float)jarg2;
4465   {
4466     try {
4467       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482   jresult = (void *)result;
4483   return jresult;
4484 }
4485
4486
4487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4488   void * jresult ;
4489   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4490   Dali::Vector2 result;
4491
4492   arg1 = (Dali::Vector2 *)jarg1;
4493   {
4494     try {
4495       result = ((Dali::Vector2 const *)arg1)->operator -();
4496     } catch (std::out_of_range& e) {
4497       {
4498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4499       };
4500     } catch (std::exception& e) {
4501       {
4502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4503       };
4504     } catch (...) {
4505       {
4506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4507       };
4508     }
4509   }
4510   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4511   return jresult;
4512 }
4513
4514
4515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4516   unsigned int jresult ;
4517   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4518   Dali::Vector2 *arg2 = 0 ;
4519   bool result;
4520
4521   arg1 = (Dali::Vector2 *)jarg1;
4522   arg2 = (Dali::Vector2 *)jarg2;
4523   if (!arg2) {
4524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4525     return 0;
4526   }
4527   {
4528     try {
4529       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4530     } catch (std::out_of_range& e) {
4531       {
4532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4533       };
4534     } catch (std::exception& e) {
4535       {
4536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4537       };
4538     } catch (...) {
4539       {
4540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4541       };
4542     }
4543   }
4544   jresult = result;
4545   return jresult;
4546 }
4547
4548
4549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4550   unsigned int jresult ;
4551   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4552   Dali::Vector2 *arg2 = 0 ;
4553   bool result;
4554
4555   arg1 = (Dali::Vector2 *)jarg1;
4556   arg2 = (Dali::Vector2 *)jarg2;
4557   if (!arg2) {
4558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4559     return 0;
4560   }
4561   {
4562     try {
4563       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4564     } catch (std::out_of_range& e) {
4565       {
4566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4567       };
4568     } catch (std::exception& e) {
4569       {
4570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4571       };
4572     } catch (...) {
4573       {
4574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4575       };
4576     }
4577   }
4578   jresult = result;
4579   return jresult;
4580 }
4581
4582
4583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4584   float jresult ;
4585   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4586   unsigned int arg2 ;
4587   float *result = 0 ;
4588
4589   arg1 = (Dali::Vector2 *)jarg1;
4590   arg2 = (unsigned int)jarg2;
4591   {
4592     try {
4593       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4594     } catch (std::out_of_range& e) {
4595       {
4596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4597       };
4598     } catch (std::exception& e) {
4599       {
4600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (...) {
4603       {
4604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4605       };
4606     }
4607   }
4608   jresult = *result;
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4614   float jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   float result;
4617
4618   arg1 = (Dali::Vector2 *)jarg1;
4619   {
4620     try {
4621       result = (float)((Dali::Vector2 const *)arg1)->Length();
4622     } catch (std::out_of_range& e) {
4623       {
4624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4625       };
4626     } catch (std::exception& e) {
4627       {
4628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (...) {
4631       {
4632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4633       };
4634     }
4635   }
4636   jresult = result;
4637   return jresult;
4638 }
4639
4640
4641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4642   float jresult ;
4643   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4644   float result;
4645
4646   arg1 = (Dali::Vector2 *)jarg1;
4647   {
4648     try {
4649       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4650     } catch (std::out_of_range& e) {
4651       {
4652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4653       };
4654     } catch (std::exception& e) {
4655       {
4656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4657       };
4658     } catch (...) {
4659       {
4660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4661       };
4662     }
4663   }
4664   jresult = result;
4665   return jresult;
4666 }
4667
4668
4669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4670   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4671
4672   arg1 = (Dali::Vector2 *)jarg1;
4673   {
4674     try {
4675       (arg1)->Normalize();
4676     } catch (std::out_of_range& e) {
4677       {
4678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4679       };
4680     } catch (std::exception& e) {
4681       {
4682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4687       };
4688     }
4689   }
4690 }
4691
4692
4693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4694   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4695   Dali::Vector2 *arg2 = 0 ;
4696   Dali::Vector2 *arg3 = 0 ;
4697
4698   arg1 = (Dali::Vector2 *)jarg1;
4699   arg2 = (Dali::Vector2 *)jarg2;
4700   if (!arg2) {
4701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4702     return ;
4703   }
4704   arg3 = (Dali::Vector2 *)jarg3;
4705   if (!arg3) {
4706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4707     return ;
4708   }
4709   {
4710     try {
4711       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4712     } catch (std::out_of_range& e) {
4713       {
4714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4715       };
4716     } catch (std::exception& e) {
4717       {
4718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4719       };
4720     } catch (...) {
4721       {
4722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4723       };
4724     }
4725   }
4726 }
4727
4728
4729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4730   void * jresult ;
4731   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4732   float *result = 0 ;
4733
4734   arg1 = (Dali::Vector2 *)jarg1;
4735   {
4736     try {
4737       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4738     } catch (std::out_of_range& e) {
4739       {
4740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4741       };
4742     } catch (std::exception& e) {
4743       {
4744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4745       };
4746     } catch (...) {
4747       {
4748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4749       };
4750     }
4751   }
4752   jresult = (void *)result;
4753   return jresult;
4754 }
4755
4756
4757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4759   float arg2 ;
4760
4761   arg1 = (Dali::Vector2 *)jarg1;
4762   arg2 = (float)jarg2;
4763   if (arg1) (arg1)->x = arg2;
4764 }
4765
4766
4767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4768   float jresult ;
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770   float result;
4771
4772   arg1 = (Dali::Vector2 *)jarg1;
4773   result = (float) ((arg1)->x);
4774   jresult = result;
4775   return jresult;
4776 }
4777
4778
4779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4780   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4781   float arg2 ;
4782
4783   arg1 = (Dali::Vector2 *)jarg1;
4784   arg2 = (float)jarg2;
4785   if (arg1) (arg1)->width = arg2;
4786 }
4787
4788
4789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4790   float jresult ;
4791   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4792   float result;
4793
4794   arg1 = (Dali::Vector2 *)jarg1;
4795   result = (float) ((arg1)->width);
4796   jresult = result;
4797   return jresult;
4798 }
4799
4800
4801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4802   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4803   float arg2 ;
4804
4805   arg1 = (Dali::Vector2 *)jarg1;
4806   arg2 = (float)jarg2;
4807   if (arg1) (arg1)->y = arg2;
4808 }
4809
4810
4811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4812   float jresult ;
4813   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4814   float result;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   result = (float) ((arg1)->y);
4818   jresult = result;
4819   return jresult;
4820 }
4821
4822
4823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4824   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4825   float arg2 ;
4826
4827   arg1 = (Dali::Vector2 *)jarg1;
4828   arg2 = (float)jarg2;
4829   if (arg1) (arg1)->height = arg2;
4830 }
4831
4832
4833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4834   float jresult ;
4835   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4836   float result;
4837
4838   arg1 = (Dali::Vector2 *)jarg1;
4839   result = (float) ((arg1)->height);
4840   jresult = result;
4841   return jresult;
4842 }
4843
4844
4845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4846   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4847
4848   arg1 = (Dali::Vector2 *)jarg1;
4849   {
4850     try {
4851       delete arg1;
4852     } catch (std::out_of_range& e) {
4853       {
4854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4855       };
4856     } catch (std::exception& e) {
4857       {
4858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4859       };
4860     } catch (...) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4863       };
4864     }
4865   }
4866 }
4867
4868
4869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4870   void * jresult ;
4871   Dali::Vector2 *arg1 = 0 ;
4872   Dali::Vector2 *arg2 = 0 ;
4873   Dali::Vector2 result;
4874
4875   arg1 = (Dali::Vector2 *)jarg1;
4876   if (!arg1) {
4877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4878     return 0;
4879   }
4880   arg2 = (Dali::Vector2 *)jarg2;
4881   if (!arg2) {
4882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4883     return 0;
4884   }
4885   {
4886     try {
4887       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4888     } catch (std::out_of_range& e) {
4889       {
4890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4891       };
4892     } catch (std::exception& e) {
4893       {
4894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4895       };
4896     } catch (...) {
4897       {
4898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4899       };
4900     }
4901   }
4902   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4903   return jresult;
4904 }
4905
4906
4907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4908   void * jresult ;
4909   Dali::Vector2 *arg1 = 0 ;
4910   Dali::Vector2 *arg2 = 0 ;
4911   Dali::Vector2 result;
4912
4913   arg1 = (Dali::Vector2 *)jarg1;
4914   if (!arg1) {
4915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4916     return 0;
4917   }
4918   arg2 = (Dali::Vector2 *)jarg2;
4919   if (!arg2) {
4920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4921     return 0;
4922   }
4923   {
4924     try {
4925       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4926     } catch (std::out_of_range& e) {
4927       {
4928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (std::exception& e) {
4931       {
4932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4933       };
4934     } catch (...) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4937       };
4938     }
4939   }
4940   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4941   return jresult;
4942 }
4943
4944
4945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4946   void * jresult ;
4947   Dali::Vector2 *arg1 = 0 ;
4948   float *arg2 = 0 ;
4949   float *arg3 = 0 ;
4950   float temp2 ;
4951   float temp3 ;
4952   Dali::Vector2 result;
4953
4954   arg1 = (Dali::Vector2 *)jarg1;
4955   if (!arg1) {
4956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4957     return 0;
4958   }
4959   temp2 = (float)jarg2;
4960   arg2 = &temp2;
4961   temp3 = (float)jarg3;
4962   arg3 = &temp3;
4963   {
4964     try {
4965       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4966     } catch (std::out_of_range& e) {
4967       {
4968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4969       };
4970     } catch (std::exception& e) {
4971       {
4972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (...) {
4975       {
4976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4977       };
4978     }
4979   }
4980   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4981   return jresult;
4982 }
4983
4984
4985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4986   void * jresult ;
4987   Dali::Vector3 *result = 0 ;
4988
4989   {
4990     try {
4991       result = (Dali::Vector3 *)new Dali::Vector3();
4992     } catch (std::out_of_range& e) {
4993       {
4994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4995       };
4996     } catch (std::exception& e) {
4997       {
4998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4999       };
5000     } catch (...) {
5001       {
5002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5003       };
5004     }
5005   }
5006   jresult = (void *)result;
5007   return jresult;
5008 }
5009
5010
5011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5012   void * jresult ;
5013   float arg1 ;
5014   float arg2 ;
5015   float arg3 ;
5016   Dali::Vector3 *result = 0 ;
5017
5018   arg1 = (float)jarg1;
5019   arg2 = (float)jarg2;
5020   arg3 = (float)jarg3;
5021   {
5022     try {
5023       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5024     } catch (std::out_of_range& e) {
5025       {
5026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5027       };
5028     } catch (std::exception& e) {
5029       {
5030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5031       };
5032     } catch (...) {
5033       {
5034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5035       };
5036     }
5037   }
5038   jresult = (void *)result;
5039   return jresult;
5040 }
5041
5042
5043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5044   void * jresult ;
5045   float *arg1 = (float *) 0 ;
5046   Dali::Vector3 *result = 0 ;
5047
5048   arg1 = jarg1;
5049   {
5050     try {
5051       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5052     } catch (std::out_of_range& e) {
5053       {
5054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5055       };
5056     } catch (std::exception& e) {
5057       {
5058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5059       };
5060     } catch (...) {
5061       {
5062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5063       };
5064     }
5065   }
5066   jresult = (void *)result;
5067
5068
5069   return jresult;
5070 }
5071
5072
5073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5074   void * jresult ;
5075   Dali::Vector2 *arg1 = 0 ;
5076   Dali::Vector3 *result = 0 ;
5077
5078   arg1 = (Dali::Vector2 *)jarg1;
5079   if (!arg1) {
5080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5081     return 0;
5082   }
5083   {
5084     try {
5085       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5086     } catch (std::out_of_range& e) {
5087       {
5088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5089       };
5090     } catch (std::exception& e) {
5091       {
5092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5093       };
5094     } catch (...) {
5095       {
5096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5097       };
5098     }
5099   }
5100   jresult = (void *)result;
5101   return jresult;
5102 }
5103
5104
5105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5106   void * jresult ;
5107   Dali::Vector4 *arg1 = 0 ;
5108   Dali::Vector3 *result = 0 ;
5109
5110   arg1 = (Dali::Vector4 *)jarg1;
5111   if (!arg1) {
5112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5113     return 0;
5114   }
5115   {
5116     try {
5117       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5118     } catch (std::out_of_range& e) {
5119       {
5120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5121       };
5122     } catch (std::exception& e) {
5123       {
5124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5125       };
5126     } catch (...) {
5127       {
5128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5129       };
5130     }
5131   }
5132   jresult = (void *)result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5138   void * jresult ;
5139   Dali::Vector3 *result = 0 ;
5140
5141   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5142   jresult = (void *)result;
5143   return jresult;
5144 }
5145
5146
5147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5148   void * jresult ;
5149   Dali::Vector3 *result = 0 ;
5150
5151   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5152   jresult = (void *)result;
5153   return jresult;
5154 }
5155
5156
5157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5158   void * jresult ;
5159   Dali::Vector3 *result = 0 ;
5160
5161   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5162   jresult = (void *)result;
5163   return jresult;
5164 }
5165
5166
5167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5168   void * jresult ;
5169   Dali::Vector3 *result = 0 ;
5170
5171   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5172   jresult = (void *)result;
5173   return jresult;
5174 }
5175
5176
5177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5178   void * jresult ;
5179   Dali::Vector3 *result = 0 ;
5180
5181   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5182   jresult = (void *)result;
5183   return jresult;
5184 }
5185
5186
5187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5188   void * jresult ;
5189   Dali::Vector3 *result = 0 ;
5190
5191   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5192   jresult = (void *)result;
5193   return jresult;
5194 }
5195
5196
5197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5198   void * jresult ;
5199   Dali::Vector3 *result = 0 ;
5200
5201   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5202   jresult = (void *)result;
5203   return jresult;
5204 }
5205
5206
5207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5208   void * jresult ;
5209   Dali::Vector3 *result = 0 ;
5210
5211   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5212   jresult = (void *)result;
5213   return jresult;
5214 }
5215
5216
5217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5218   void * jresult ;
5219   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5220   float *arg2 = (float *) 0 ;
5221   Dali::Vector3 *result = 0 ;
5222
5223   arg1 = (Dali::Vector3 *)jarg1;
5224   arg2 = jarg2;
5225   {
5226     try {
5227       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5228     } catch (std::out_of_range& e) {
5229       {
5230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5231       };
5232     } catch (std::exception& e) {
5233       {
5234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5235       };
5236     } catch (...) {
5237       {
5238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5239       };
5240     }
5241   }
5242   jresult = (void *)result;
5243
5244
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5250   void * jresult ;
5251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5252   Dali::Vector2 *arg2 = 0 ;
5253   Dali::Vector3 *result = 0 ;
5254
5255   arg1 = (Dali::Vector3 *)jarg1;
5256   arg2 = (Dali::Vector2 *)jarg2;
5257   if (!arg2) {
5258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5259     return 0;
5260   }
5261   {
5262     try {
5263       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5264     } catch (std::out_of_range& e) {
5265       {
5266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5267       };
5268     } catch (std::exception& e) {
5269       {
5270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5271       };
5272     } catch (...) {
5273       {
5274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5275       };
5276     }
5277   }
5278   jresult = (void *)result;
5279   return jresult;
5280 }
5281
5282
5283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5284   void * jresult ;
5285   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5286   Dali::Vector4 *arg2 = 0 ;
5287   Dali::Vector3 *result = 0 ;
5288
5289   arg1 = (Dali::Vector3 *)jarg1;
5290   arg2 = (Dali::Vector4 *)jarg2;
5291   if (!arg2) {
5292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5293     return 0;
5294   }
5295   {
5296     try {
5297       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5298     } catch (std::out_of_range& e) {
5299       {
5300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5301       };
5302     } catch (std::exception& e) {
5303       {
5304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5305       };
5306     } catch (...) {
5307       {
5308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5309       };
5310     }
5311   }
5312   jresult = (void *)result;
5313   return jresult;
5314 }
5315
5316
5317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5318   void * jresult ;
5319   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5320   Dali::Vector3 *arg2 = 0 ;
5321   Dali::Vector3 result;
5322
5323   arg1 = (Dali::Vector3 *)jarg1;
5324   arg2 = (Dali::Vector3 *)jarg2;
5325   if (!arg2) {
5326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5327     return 0;
5328   }
5329   {
5330     try {
5331       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5332     } catch (std::out_of_range& e) {
5333       {
5334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5335       };
5336     } catch (std::exception& e) {
5337       {
5338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5339       };
5340     } catch (...) {
5341       {
5342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5343       };
5344     }
5345   }
5346   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5347   return jresult;
5348 }
5349
5350
5351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5352   void * jresult ;
5353   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5354   Dali::Vector3 *arg2 = 0 ;
5355   Dali::Vector3 *result = 0 ;
5356
5357   arg1 = (Dali::Vector3 *)jarg1;
5358   arg2 = (Dali::Vector3 *)jarg2;
5359   if (!arg2) {
5360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5361     return 0;
5362   }
5363   {
5364     try {
5365       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5366     } catch (std::out_of_range& e) {
5367       {
5368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5369       };
5370     } catch (std::exception& e) {
5371       {
5372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5373       };
5374     } catch (...) {
5375       {
5376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5377       };
5378     }
5379   }
5380   jresult = (void *)result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5386   void * jresult ;
5387   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5388   Dali::Vector3 *arg2 = 0 ;
5389   Dali::Vector3 result;
5390
5391   arg1 = (Dali::Vector3 *)jarg1;
5392   arg2 = (Dali::Vector3 *)jarg2;
5393   if (!arg2) {
5394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5395     return 0;
5396   }
5397   {
5398     try {
5399       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5400     } catch (std::out_of_range& e) {
5401       {
5402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5403       };
5404     } catch (std::exception& e) {
5405       {
5406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5407       };
5408     } catch (...) {
5409       {
5410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5411       };
5412     }
5413   }
5414   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5420   void * jresult ;
5421   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5422   Dali::Vector3 *arg2 = 0 ;
5423   Dali::Vector3 *result = 0 ;
5424
5425   arg1 = (Dali::Vector3 *)jarg1;
5426   arg2 = (Dali::Vector3 *)jarg2;
5427   if (!arg2) {
5428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5429     return 0;
5430   }
5431   {
5432     try {
5433       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5441       };
5442     } catch (...) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5445       };
5446     }
5447   }
5448   jresult = (void *)result;
5449   return jresult;
5450 }
5451
5452
5453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5454   void * jresult ;
5455   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5456   Dali::Vector3 *arg2 = 0 ;
5457   Dali::Vector3 result;
5458
5459   arg1 = (Dali::Vector3 *)jarg1;
5460   arg2 = (Dali::Vector3 *)jarg2;
5461   if (!arg2) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5463     return 0;
5464   }
5465   {
5466     try {
5467       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5468     } catch (std::out_of_range& e) {
5469       {
5470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (std::exception& e) {
5473       {
5474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5483   return jresult;
5484 }
5485
5486
5487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5488   void * jresult ;
5489   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5490   float arg2 ;
5491   Dali::Vector3 result;
5492
5493   arg1 = (Dali::Vector3 *)jarg1;
5494   arg2 = (float)jarg2;
5495   {
5496     try {
5497       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5498     } catch (std::out_of_range& e) {
5499       {
5500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5501       };
5502     } catch (std::exception& e) {
5503       {
5504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5505       };
5506     } catch (...) {
5507       {
5508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5509       };
5510     }
5511   }
5512   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5513   return jresult;
5514 }
5515
5516
5517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5518   void * jresult ;
5519   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5520   Dali::Vector3 *arg2 = 0 ;
5521   Dali::Vector3 *result = 0 ;
5522
5523   arg1 = (Dali::Vector3 *)jarg1;
5524   arg2 = (Dali::Vector3 *)jarg2;
5525   if (!arg2) {
5526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5527     return 0;
5528   }
5529   {
5530     try {
5531       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5532     } catch (std::out_of_range& e) {
5533       {
5534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5535       };
5536     } catch (std::exception& e) {
5537       {
5538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (...) {
5541       {
5542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5543       };
5544     }
5545   }
5546   jresult = (void *)result;
5547   return jresult;
5548 }
5549
5550
5551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5552   void * jresult ;
5553   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5554   float arg2 ;
5555   Dali::Vector3 *result = 0 ;
5556
5557   arg1 = (Dali::Vector3 *)jarg1;
5558   arg2 = (float)jarg2;
5559   {
5560     try {
5561       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5562     } catch (std::out_of_range& e) {
5563       {
5564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5565       };
5566     } catch (std::exception& e) {
5567       {
5568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5569       };
5570     } catch (...) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5573       };
5574     }
5575   }
5576   jresult = (void *)result;
5577   return jresult;
5578 }
5579
5580
5581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5582   void * jresult ;
5583   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5584   Dali::Quaternion *arg2 = 0 ;
5585   Dali::Vector3 *result = 0 ;
5586
5587   arg1 = (Dali::Vector3 *)jarg1;
5588   arg2 = (Dali::Quaternion *)jarg2;
5589   if (!arg2) {
5590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5591     return 0;
5592   }
5593   {
5594     try {
5595       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (...) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5607       };
5608     }
5609   }
5610   jresult = (void *)result;
5611   return jresult;
5612 }
5613
5614
5615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5616   void * jresult ;
5617   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5618   Dali::Vector3 *arg2 = 0 ;
5619   Dali::Vector3 result;
5620
5621   arg1 = (Dali::Vector3 *)jarg1;
5622   arg2 = (Dali::Vector3 *)jarg2;
5623   if (!arg2) {
5624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5625     return 0;
5626   }
5627   {
5628     try {
5629       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5630     } catch (std::out_of_range& e) {
5631       {
5632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (std::exception& e) {
5635       {
5636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5637       };
5638     } catch (...) {
5639       {
5640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5641       };
5642     }
5643   }
5644   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5645   return jresult;
5646 }
5647
5648
5649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5650   void * jresult ;
5651   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5652   float arg2 ;
5653   Dali::Vector3 result;
5654
5655   arg1 = (Dali::Vector3 *)jarg1;
5656   arg2 = (float)jarg2;
5657   {
5658     try {
5659       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5660     } catch (std::out_of_range& e) {
5661       {
5662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (std::exception& e) {
5665       {
5666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (...) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5671       };
5672     }
5673   }
5674   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5680   void * jresult ;
5681   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5682   Dali::Vector3 *arg2 = 0 ;
5683   Dali::Vector3 *result = 0 ;
5684
5685   arg1 = (Dali::Vector3 *)jarg1;
5686   arg2 = (Dali::Vector3 *)jarg2;
5687   if (!arg2) {
5688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5689     return 0;
5690   }
5691   {
5692     try {
5693       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5694     } catch (std::out_of_range& e) {
5695       {
5696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5697       };
5698     } catch (std::exception& e) {
5699       {
5700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (...) {
5703       {
5704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5705       };
5706     }
5707   }
5708   jresult = (void *)result;
5709   return jresult;
5710 }
5711
5712
5713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5714   void * jresult ;
5715   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5716   float arg2 ;
5717   Dali::Vector3 *result = 0 ;
5718
5719   arg1 = (Dali::Vector3 *)jarg1;
5720   arg2 = (float)jarg2;
5721   {
5722     try {
5723       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5724     } catch (std::out_of_range& e) {
5725       {
5726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5727       };
5728     } catch (std::exception& e) {
5729       {
5730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5731       };
5732     } catch (...) {
5733       {
5734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5735       };
5736     }
5737   }
5738   jresult = (void *)result;
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5744   void * jresult ;
5745   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5746   Dali::Vector3 result;
5747
5748   arg1 = (Dali::Vector3 *)jarg1;
5749   {
5750     try {
5751       result = ((Dali::Vector3 const *)arg1)->operator -();
5752     } catch (std::out_of_range& e) {
5753       {
5754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5755       };
5756     } catch (std::exception& e) {
5757       {
5758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5759       };
5760     } catch (...) {
5761       {
5762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5763       };
5764     }
5765   }
5766   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5767   return jresult;
5768 }
5769
5770
5771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5772   unsigned int jresult ;
5773   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5774   Dali::Vector3 *arg2 = 0 ;
5775   bool result;
5776
5777   arg1 = (Dali::Vector3 *)jarg1;
5778   arg2 = (Dali::Vector3 *)jarg2;
5779   if (!arg2) {
5780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5781     return 0;
5782   }
5783   {
5784     try {
5785       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5786     } catch (std::out_of_range& e) {
5787       {
5788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5789       };
5790     } catch (std::exception& e) {
5791       {
5792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5793       };
5794     } catch (...) {
5795       {
5796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5797       };
5798     }
5799   }
5800   jresult = result;
5801   return jresult;
5802 }
5803
5804
5805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5806   unsigned int jresult ;
5807   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5808   Dali::Vector3 *arg2 = 0 ;
5809   bool result;
5810
5811   arg1 = (Dali::Vector3 *)jarg1;
5812   arg2 = (Dali::Vector3 *)jarg2;
5813   if (!arg2) {
5814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5815     return 0;
5816   }
5817   {
5818     try {
5819       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5820     } catch (std::out_of_range& e) {
5821       {
5822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5823       };
5824     } catch (std::exception& e) {
5825       {
5826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5827       };
5828     } catch (...) {
5829       {
5830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5831       };
5832     }
5833   }
5834   jresult = result;
5835   return jresult;
5836 }
5837
5838
5839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5840   float jresult ;
5841   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5842   unsigned int arg2 ;
5843   float *result = 0 ;
5844
5845   arg1 = (Dali::Vector3 *)jarg1;
5846   arg2 = (unsigned int)jarg2;
5847   {
5848     try {
5849       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5850     } catch (std::out_of_range& e) {
5851       {
5852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5853       };
5854     } catch (std::exception& e) {
5855       {
5856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (...) {
5859       {
5860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5861       };
5862     }
5863   }
5864   jresult = *result;
5865   return jresult;
5866 }
5867
5868
5869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5870   float jresult ;
5871   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5872   Dali::Vector3 *arg2 = 0 ;
5873   float result;
5874
5875   arg1 = (Dali::Vector3 *)jarg1;
5876   arg2 = (Dali::Vector3 *)jarg2;
5877   if (!arg2) {
5878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5879     return 0;
5880   }
5881   {
5882     try {
5883       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5884     } catch (std::out_of_range& e) {
5885       {
5886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5887       };
5888     } catch (std::exception& e) {
5889       {
5890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (...) {
5893       {
5894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5895       };
5896     }
5897   }
5898   jresult = result;
5899   return jresult;
5900 }
5901
5902
5903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5904   void * jresult ;
5905   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5906   Dali::Vector3 *arg2 = 0 ;
5907   Dali::Vector3 result;
5908
5909   arg1 = (Dali::Vector3 *)jarg1;
5910   arg2 = (Dali::Vector3 *)jarg2;
5911   if (!arg2) {
5912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5913     return 0;
5914   }
5915   {
5916     try {
5917       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5918     } catch (std::out_of_range& e) {
5919       {
5920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5921       };
5922     } catch (std::exception& e) {
5923       {
5924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5925       };
5926     } catch (...) {
5927       {
5928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5929       };
5930     }
5931   }
5932   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5933   return jresult;
5934 }
5935
5936
5937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5938   float jresult ;
5939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5940   float result;
5941
5942   arg1 = (Dali::Vector3 *)jarg1;
5943   {
5944     try {
5945       result = (float)((Dali::Vector3 const *)arg1)->Length();
5946     } catch (std::out_of_range& e) {
5947       {
5948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5949       };
5950     } catch (std::exception& e) {
5951       {
5952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5953       };
5954     } catch (...) {
5955       {
5956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5957       };
5958     }
5959   }
5960   jresult = result;
5961   return jresult;
5962 }
5963
5964
5965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5966   float jresult ;
5967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5968   float result;
5969
5970   arg1 = (Dali::Vector3 *)jarg1;
5971   {
5972     try {
5973       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5974     } catch (std::out_of_range& e) {
5975       {
5976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (std::exception& e) {
5979       {
5980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5981       };
5982     } catch (...) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5985       };
5986     }
5987   }
5988   jresult = result;
5989   return jresult;
5990 }
5991
5992
5993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5995
5996   arg1 = (Dali::Vector3 *)jarg1;
5997   {
5998     try {
5999       (arg1)->Normalize();
6000     } catch (std::out_of_range& e) {
6001       {
6002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6003       };
6004     } catch (std::exception& e) {
6005       {
6006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6007       };
6008     } catch (...) {
6009       {
6010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6011       };
6012     }
6013   }
6014 }
6015
6016
6017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6019   Dali::Vector3 *arg2 = 0 ;
6020   Dali::Vector3 *arg3 = 0 ;
6021
6022   arg1 = (Dali::Vector3 *)jarg1;
6023   arg2 = (Dali::Vector3 *)jarg2;
6024   if (!arg2) {
6025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6026     return ;
6027   }
6028   arg3 = (Dali::Vector3 *)jarg3;
6029   if (!arg3) {
6030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6031     return ;
6032   }
6033   {
6034     try {
6035       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6036     } catch (std::out_of_range& e) {
6037       {
6038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6039       };
6040     } catch (std::exception& e) {
6041       {
6042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6043       };
6044     } catch (...) {
6045       {
6046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6047       };
6048     }
6049   }
6050 }
6051
6052
6053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6054   void * jresult ;
6055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6056   float *result = 0 ;
6057
6058   arg1 = (Dali::Vector3 *)jarg1;
6059   {
6060     try {
6061       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6062     } catch (std::out_of_range& e) {
6063       {
6064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6065       };
6066     } catch (std::exception& e) {
6067       {
6068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6069       };
6070     } catch (...) {
6071       {
6072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6073       };
6074     }
6075   }
6076   jresult = (void *)result;
6077   return jresult;
6078 }
6079
6080
6081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6082   void * jresult ;
6083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6084   Dali::Vector2 *result = 0 ;
6085
6086   arg1 = (Dali::Vector3 *)jarg1;
6087   {
6088     try {
6089       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6090     } catch (std::out_of_range& e) {
6091       {
6092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6093       };
6094     } catch (std::exception& e) {
6095       {
6096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6097       };
6098     } catch (...) {
6099       {
6100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6101       };
6102     }
6103   }
6104   jresult = (void *)result;
6105   return jresult;
6106 }
6107
6108
6109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6110   void * jresult ;
6111   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6112   Dali::Vector2 *result = 0 ;
6113
6114   arg1 = (Dali::Vector3 *)jarg1;
6115   {
6116     try {
6117       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6118     } catch (std::out_of_range& e) {
6119       {
6120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6121       };
6122     } catch (std::exception& e) {
6123       {
6124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6125       };
6126     } catch (...) {
6127       {
6128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6129       };
6130     }
6131   }
6132   jresult = (void *)result;
6133   return jresult;
6134 }
6135
6136
6137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6138   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6139   float arg2 ;
6140
6141   arg1 = (Dali::Vector3 *)jarg1;
6142   arg2 = (float)jarg2;
6143   if (arg1) (arg1)->x = arg2;
6144 }
6145
6146
6147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6148   float jresult ;
6149   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6150   float result;
6151
6152   arg1 = (Dali::Vector3 *)jarg1;
6153   result = (float) ((arg1)->x);
6154   jresult = result;
6155   return jresult;
6156 }
6157
6158
6159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6160   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6161   float arg2 ;
6162
6163   arg1 = (Dali::Vector3 *)jarg1;
6164   arg2 = (float)jarg2;
6165   if (arg1) (arg1)->width = arg2;
6166 }
6167
6168
6169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6170   float jresult ;
6171   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6172   float result;
6173
6174   arg1 = (Dali::Vector3 *)jarg1;
6175   result = (float) ((arg1)->width);
6176   jresult = result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6182   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6183   float arg2 ;
6184
6185   arg1 = (Dali::Vector3 *)jarg1;
6186   arg2 = (float)jarg2;
6187   if (arg1) (arg1)->r = arg2;
6188 }
6189
6190
6191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6192   float jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   float result;
6195
6196   arg1 = (Dali::Vector3 *)jarg1;
6197   result = (float) ((arg1)->r);
6198   jresult = result;
6199   return jresult;
6200 }
6201
6202
6203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6204   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6205   float arg2 ;
6206
6207   arg1 = (Dali::Vector3 *)jarg1;
6208   arg2 = (float)jarg2;
6209   if (arg1) (arg1)->y = arg2;
6210 }
6211
6212
6213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6214   float jresult ;
6215   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6216   float result;
6217
6218   arg1 = (Dali::Vector3 *)jarg1;
6219   result = (float) ((arg1)->y);
6220   jresult = result;
6221   return jresult;
6222 }
6223
6224
6225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6226   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6227   float arg2 ;
6228
6229   arg1 = (Dali::Vector3 *)jarg1;
6230   arg2 = (float)jarg2;
6231   if (arg1) (arg1)->height = arg2;
6232 }
6233
6234
6235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6236   float jresult ;
6237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6238   float result;
6239
6240   arg1 = (Dali::Vector3 *)jarg1;
6241   result = (float) ((arg1)->height);
6242   jresult = result;
6243   return jresult;
6244 }
6245
6246
6247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6248   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6249   float arg2 ;
6250
6251   arg1 = (Dali::Vector3 *)jarg1;
6252   arg2 = (float)jarg2;
6253   if (arg1) (arg1)->g = arg2;
6254 }
6255
6256
6257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6258   float jresult ;
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   float result;
6261
6262   arg1 = (Dali::Vector3 *)jarg1;
6263   result = (float) ((arg1)->g);
6264   jresult = result;
6265   return jresult;
6266 }
6267
6268
6269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6270   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6271   float arg2 ;
6272
6273   arg1 = (Dali::Vector3 *)jarg1;
6274   arg2 = (float)jarg2;
6275   if (arg1) (arg1)->z = arg2;
6276 }
6277
6278
6279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6280   float jresult ;
6281   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6282   float result;
6283
6284   arg1 = (Dali::Vector3 *)jarg1;
6285   result = (float) ((arg1)->z);
6286   jresult = result;
6287   return jresult;
6288 }
6289
6290
6291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6292   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6293   float arg2 ;
6294
6295   arg1 = (Dali::Vector3 *)jarg1;
6296   arg2 = (float)jarg2;
6297   if (arg1) (arg1)->depth = arg2;
6298 }
6299
6300
6301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6302   float jresult ;
6303   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6304   float result;
6305
6306   arg1 = (Dali::Vector3 *)jarg1;
6307   result = (float) ((arg1)->depth);
6308   jresult = result;
6309   return jresult;
6310 }
6311
6312
6313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6314   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6315   float arg2 ;
6316
6317   arg1 = (Dali::Vector3 *)jarg1;
6318   arg2 = (float)jarg2;
6319   if (arg1) (arg1)->b = arg2;
6320 }
6321
6322
6323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6324   float jresult ;
6325   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6326   float result;
6327
6328   arg1 = (Dali::Vector3 *)jarg1;
6329   result = (float) ((arg1)->b);
6330   jresult = result;
6331   return jresult;
6332 }
6333
6334
6335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6336   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6337
6338   arg1 = (Dali::Vector3 *)jarg1;
6339   {
6340     try {
6341       delete arg1;
6342     } catch (std::out_of_range& e) {
6343       {
6344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6345       };
6346     } catch (std::exception& e) {
6347       {
6348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6349       };
6350     } catch (...) {
6351       {
6352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6353       };
6354     }
6355   }
6356 }
6357
6358
6359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6360   void * jresult ;
6361   Dali::Vector3 *arg1 = 0 ;
6362   Dali::Vector3 *arg2 = 0 ;
6363   Dali::Vector3 result;
6364
6365   arg1 = (Dali::Vector3 *)jarg1;
6366   if (!arg1) {
6367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6368     return 0;
6369   }
6370   arg2 = (Dali::Vector3 *)jarg2;
6371   if (!arg2) {
6372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6373     return 0;
6374   }
6375   {
6376     try {
6377       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6378     } catch (std::out_of_range& e) {
6379       {
6380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6381       };
6382     } catch (std::exception& e) {
6383       {
6384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6385       };
6386     } catch (...) {
6387       {
6388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6389       };
6390     }
6391   }
6392   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6393   return jresult;
6394 }
6395
6396
6397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6398   void * jresult ;
6399   Dali::Vector3 *arg1 = 0 ;
6400   Dali::Vector3 *arg2 = 0 ;
6401   Dali::Vector3 result;
6402
6403   arg1 = (Dali::Vector3 *)jarg1;
6404   if (!arg1) {
6405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6406     return 0;
6407   }
6408   arg2 = (Dali::Vector3 *)jarg2;
6409   if (!arg2) {
6410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6411     return 0;
6412   }
6413   {
6414     try {
6415       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6416     } catch (std::out_of_range& e) {
6417       {
6418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6419       };
6420     } catch (std::exception& e) {
6421       {
6422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6423       };
6424     } catch (...) {
6425       {
6426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6427       };
6428     }
6429   }
6430   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6431   return jresult;
6432 }
6433
6434
6435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6436   void * jresult ;
6437   Dali::Vector3 *arg1 = 0 ;
6438   float *arg2 = 0 ;
6439   float *arg3 = 0 ;
6440   float temp2 ;
6441   float temp3 ;
6442   Dali::Vector3 result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   if (!arg1) {
6446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6447     return 0;
6448   }
6449   temp2 = (float)jarg2;
6450   arg2 = &temp2;
6451   temp3 = (float)jarg3;
6452   arg3 = &temp3;
6453   {
6454     try {
6455       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6456     } catch (std::out_of_range& e) {
6457       {
6458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6459       };
6460     } catch (std::exception& e) {
6461       {
6462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (...) {
6465       {
6466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6467       };
6468     }
6469   }
6470   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6471   return jresult;
6472 }
6473
6474
6475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6476   void * jresult ;
6477   Dali::Vector4 *result = 0 ;
6478
6479   {
6480     try {
6481       result = (Dali::Vector4 *)new Dali::Vector4();
6482     } catch (std::out_of_range& e) {
6483       {
6484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6485       };
6486     } catch (std::exception& e) {
6487       {
6488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6489       };
6490     } catch (...) {
6491       {
6492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6493       };
6494     }
6495   }
6496   jresult = (void *)result;
6497   return jresult;
6498 }
6499
6500
6501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6502   void * jresult ;
6503   float arg1 ;
6504   float arg2 ;
6505   float arg3 ;
6506   float arg4 ;
6507   Dali::Vector4 *result = 0 ;
6508
6509   arg1 = (float)jarg1;
6510   arg2 = (float)jarg2;
6511   arg3 = (float)jarg3;
6512   arg4 = (float)jarg4;
6513   {
6514     try {
6515       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6516     } catch (std::out_of_range& e) {
6517       {
6518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6519       };
6520     } catch (std::exception& e) {
6521       {
6522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6523       };
6524     } catch (...) {
6525       {
6526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6527       };
6528     }
6529   }
6530   jresult = (void *)result;
6531   return jresult;
6532 }
6533
6534
6535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6536   void * jresult ;
6537   float *arg1 = (float *) 0 ;
6538   Dali::Vector4 *result = 0 ;
6539
6540   arg1 = jarg1;
6541   {
6542     try {
6543       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6544     } catch (std::out_of_range& e) {
6545       {
6546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6547       };
6548     } catch (std::exception& e) {
6549       {
6550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6551       };
6552     } catch (...) {
6553       {
6554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6555       };
6556     }
6557   }
6558   jresult = (void *)result;
6559
6560
6561   return jresult;
6562 }
6563
6564
6565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6566   void * jresult ;
6567   Dali::Vector2 *arg1 = 0 ;
6568   Dali::Vector4 *result = 0 ;
6569
6570   arg1 = (Dali::Vector2 *)jarg1;
6571   if (!arg1) {
6572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6573     return 0;
6574   }
6575   {
6576     try {
6577       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6578     } catch (std::out_of_range& e) {
6579       {
6580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (std::exception& e) {
6583       {
6584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592   jresult = (void *)result;
6593   return jresult;
6594 }
6595
6596
6597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6598   void * jresult ;
6599   Dali::Vector3 *arg1 = 0 ;
6600   Dali::Vector4 *result = 0 ;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   if (!arg1) {
6604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6605     return 0;
6606   }
6607   {
6608     try {
6609       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6610     } catch (std::out_of_range& e) {
6611       {
6612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6613       };
6614     } catch (std::exception& e) {
6615       {
6616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6617       };
6618     } catch (...) {
6619       {
6620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6621       };
6622     }
6623   }
6624   jresult = (void *)result;
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6630   void * jresult ;
6631   Dali::Vector4 *result = 0 ;
6632
6633   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6634   jresult = (void *)result;
6635   return jresult;
6636 }
6637
6638
6639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6640   void * jresult ;
6641   Dali::Vector4 *result = 0 ;
6642
6643   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6644   jresult = (void *)result;
6645   return jresult;
6646 }
6647
6648
6649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6650   void * jresult ;
6651   Dali::Vector4 *result = 0 ;
6652
6653   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6654   jresult = (void *)result;
6655   return jresult;
6656 }
6657
6658
6659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6660   void * jresult ;
6661   Dali::Vector4 *result = 0 ;
6662
6663   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6664   jresult = (void *)result;
6665   return jresult;
6666 }
6667
6668
6669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6670   void * jresult ;
6671   Dali::Vector4 *result = 0 ;
6672
6673   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6674   jresult = (void *)result;
6675   return jresult;
6676 }
6677
6678
6679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6680   void * jresult ;
6681   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6682   float *arg2 = (float *) 0 ;
6683   Dali::Vector4 *result = 0 ;
6684
6685   arg1 = (Dali::Vector4 *)jarg1;
6686   arg2 = jarg2;
6687   {
6688     try {
6689       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6690     } catch (std::out_of_range& e) {
6691       {
6692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6693       };
6694     } catch (std::exception& e) {
6695       {
6696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6697       };
6698     } catch (...) {
6699       {
6700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6701       };
6702     }
6703   }
6704   jresult = (void *)result;
6705
6706
6707   return jresult;
6708 }
6709
6710
6711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6712   void * jresult ;
6713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6714   Dali::Vector2 *arg2 = 0 ;
6715   Dali::Vector4 *result = 0 ;
6716
6717   arg1 = (Dali::Vector4 *)jarg1;
6718   arg2 = (Dali::Vector2 *)jarg2;
6719   if (!arg2) {
6720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6721     return 0;
6722   }
6723   {
6724     try {
6725       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6726     } catch (std::out_of_range& e) {
6727       {
6728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6729       };
6730     } catch (std::exception& e) {
6731       {
6732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6733       };
6734     } catch (...) {
6735       {
6736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6737       };
6738     }
6739   }
6740   jresult = (void *)result;
6741   return jresult;
6742 }
6743
6744
6745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6746   void * jresult ;
6747   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6748   Dali::Vector3 *arg2 = 0 ;
6749   Dali::Vector4 *result = 0 ;
6750
6751   arg1 = (Dali::Vector4 *)jarg1;
6752   arg2 = (Dali::Vector3 *)jarg2;
6753   if (!arg2) {
6754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6755     return 0;
6756   }
6757   {
6758     try {
6759       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6760     } catch (std::out_of_range& e) {
6761       {
6762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6763       };
6764     } catch (std::exception& e) {
6765       {
6766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6767       };
6768     } catch (...) {
6769       {
6770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6771       };
6772     }
6773   }
6774   jresult = (void *)result;
6775   return jresult;
6776 }
6777
6778
6779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6780   void * jresult ;
6781   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6782   Dali::Vector4 *arg2 = 0 ;
6783   Dali::Vector4 result;
6784
6785   arg1 = (Dali::Vector4 *)jarg1;
6786   arg2 = (Dali::Vector4 *)jarg2;
6787   if (!arg2) {
6788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6789     return 0;
6790   }
6791   {
6792     try {
6793       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6794     } catch (std::out_of_range& e) {
6795       {
6796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6797       };
6798     } catch (std::exception& e) {
6799       {
6800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6805       };
6806     }
6807   }
6808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6809   return jresult;
6810 }
6811
6812
6813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6814   void * jresult ;
6815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6816   Dali::Vector4 *arg2 = 0 ;
6817   Dali::Vector4 *result = 0 ;
6818
6819   arg1 = (Dali::Vector4 *)jarg1;
6820   arg2 = (Dali::Vector4 *)jarg2;
6821   if (!arg2) {
6822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6823     return 0;
6824   }
6825   {
6826     try {
6827       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6828     } catch (std::out_of_range& e) {
6829       {
6830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (std::exception& e) {
6833       {
6834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6835       };
6836     } catch (...) {
6837       {
6838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6839       };
6840     }
6841   }
6842   jresult = (void *)result;
6843   return jresult;
6844 }
6845
6846
6847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6848   void * jresult ;
6849   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6850   Dali::Vector4 *arg2 = 0 ;
6851   Dali::Vector4 result;
6852
6853   arg1 = (Dali::Vector4 *)jarg1;
6854   arg2 = (Dali::Vector4 *)jarg2;
6855   if (!arg2) {
6856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6857     return 0;
6858   }
6859   {
6860     try {
6861       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6862     } catch (std::out_of_range& e) {
6863       {
6864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6865       };
6866     } catch (std::exception& e) {
6867       {
6868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6869       };
6870     } catch (...) {
6871       {
6872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6873       };
6874     }
6875   }
6876   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6882   void * jresult ;
6883   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6884   Dali::Vector4 *arg2 = 0 ;
6885   Dali::Vector4 *result = 0 ;
6886
6887   arg1 = (Dali::Vector4 *)jarg1;
6888   arg2 = (Dali::Vector4 *)jarg2;
6889   if (!arg2) {
6890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6891     return 0;
6892   }
6893   {
6894     try {
6895       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6896     } catch (std::out_of_range& e) {
6897       {
6898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (std::exception& e) {
6901       {
6902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910   jresult = (void *)result;
6911   return jresult;
6912 }
6913
6914
6915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6916   void * jresult ;
6917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6918   Dali::Vector4 *arg2 = 0 ;
6919   Dali::Vector4 result;
6920
6921   arg1 = (Dali::Vector4 *)jarg1;
6922   arg2 = (Dali::Vector4 *)jarg2;
6923   if (!arg2) {
6924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6925     return 0;
6926   }
6927   {
6928     try {
6929       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6930     } catch (std::out_of_range& e) {
6931       {
6932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6933       };
6934     } catch (std::exception& e) {
6935       {
6936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6937       };
6938     } catch (...) {
6939       {
6940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6941       };
6942     }
6943   }
6944   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6950   void * jresult ;
6951   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6952   float arg2 ;
6953   Dali::Vector4 result;
6954
6955   arg1 = (Dali::Vector4 *)jarg1;
6956   arg2 = (float)jarg2;
6957   {
6958     try {
6959       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6960     } catch (std::out_of_range& e) {
6961       {
6962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6963       };
6964     } catch (std::exception& e) {
6965       {
6966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6967       };
6968     } catch (...) {
6969       {
6970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6971       };
6972     }
6973   }
6974   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6975   return jresult;
6976 }
6977
6978
6979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6980   void * jresult ;
6981   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6982   Dali::Vector4 *arg2 = 0 ;
6983   Dali::Vector4 *result = 0 ;
6984
6985   arg1 = (Dali::Vector4 *)jarg1;
6986   arg2 = (Dali::Vector4 *)jarg2;
6987   if (!arg2) {
6988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6989     return 0;
6990   }
6991   {
6992     try {
6993       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6994     } catch (std::out_of_range& e) {
6995       {
6996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6997       };
6998     } catch (std::exception& e) {
6999       {
7000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (...) {
7003       {
7004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7005       };
7006     }
7007   }
7008   jresult = (void *)result;
7009   return jresult;
7010 }
7011
7012
7013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7014   void * jresult ;
7015   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7016   float arg2 ;
7017   Dali::Vector4 *result = 0 ;
7018
7019   arg1 = (Dali::Vector4 *)jarg1;
7020   arg2 = (float)jarg2;
7021   {
7022     try {
7023       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7024     } catch (std::out_of_range& e) {
7025       {
7026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7027       };
7028     } catch (std::exception& e) {
7029       {
7030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7031       };
7032     } catch (...) {
7033       {
7034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7035       };
7036     }
7037   }
7038   jresult = (void *)result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7044   void * jresult ;
7045   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7046   Dali::Vector4 *arg2 = 0 ;
7047   Dali::Vector4 result;
7048
7049   arg1 = (Dali::Vector4 *)jarg1;
7050   arg2 = (Dali::Vector4 *)jarg2;
7051   if (!arg2) {
7052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7053     return 0;
7054   }
7055   {
7056     try {
7057       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7058     } catch (std::out_of_range& e) {
7059       {
7060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7061       };
7062     } catch (std::exception& e) {
7063       {
7064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (...) {
7067       {
7068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7069       };
7070     }
7071   }
7072   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7073   return jresult;
7074 }
7075
7076
7077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7078   void * jresult ;
7079   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7080   float arg2 ;
7081   Dali::Vector4 result;
7082
7083   arg1 = (Dali::Vector4 *)jarg1;
7084   arg2 = (float)jarg2;
7085   {
7086     try {
7087       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7088     } catch (std::out_of_range& e) {
7089       {
7090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7091       };
7092     } catch (std::exception& e) {
7093       {
7094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7095       };
7096     } catch (...) {
7097       {
7098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7099       };
7100     }
7101   }
7102   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7108   void * jresult ;
7109   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7110   Dali::Vector4 *arg2 = 0 ;
7111   Dali::Vector4 *result = 0 ;
7112
7113   arg1 = (Dali::Vector4 *)jarg1;
7114   arg2 = (Dali::Vector4 *)jarg2;
7115   if (!arg2) {
7116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7117     return 0;
7118   }
7119   {
7120     try {
7121       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7122     } catch (std::out_of_range& e) {
7123       {
7124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7125       };
7126     } catch (std::exception& e) {
7127       {
7128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7129       };
7130     } catch (...) {
7131       {
7132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7133       };
7134     }
7135   }
7136   jresult = (void *)result;
7137   return jresult;
7138 }
7139
7140
7141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7142   void * jresult ;
7143   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7144   float arg2 ;
7145   Dali::Vector4 *result = 0 ;
7146
7147   arg1 = (Dali::Vector4 *)jarg1;
7148   arg2 = (float)jarg2;
7149   {
7150     try {
7151       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7152     } catch (std::out_of_range& e) {
7153       {
7154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7155       };
7156     } catch (std::exception& e) {
7157       {
7158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (...) {
7161       {
7162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7163       };
7164     }
7165   }
7166   jresult = (void *)result;
7167   return jresult;
7168 }
7169
7170
7171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7172   void * jresult ;
7173   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7174   Dali::Vector4 result;
7175
7176   arg1 = (Dali::Vector4 *)jarg1;
7177   {
7178     try {
7179       result = ((Dali::Vector4 const *)arg1)->operator -();
7180     } catch (std::out_of_range& e) {
7181       {
7182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7183       };
7184     } catch (std::exception& e) {
7185       {
7186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7187       };
7188     } catch (...) {
7189       {
7190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7191       };
7192     }
7193   }
7194   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7195   return jresult;
7196 }
7197
7198
7199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7200   unsigned int jresult ;
7201   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7202   Dali::Vector4 *arg2 = 0 ;
7203   bool result;
7204
7205   arg1 = (Dali::Vector4 *)jarg1;
7206   arg2 = (Dali::Vector4 *)jarg2;
7207   if (!arg2) {
7208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7209     return 0;
7210   }
7211   {
7212     try {
7213       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7214     } catch (std::out_of_range& e) {
7215       {
7216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7217       };
7218     } catch (std::exception& e) {
7219       {
7220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7221       };
7222     } catch (...) {
7223       {
7224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7225       };
7226     }
7227   }
7228   jresult = result;
7229   return jresult;
7230 }
7231
7232
7233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7234   unsigned int jresult ;
7235   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7236   Dali::Vector4 *arg2 = 0 ;
7237   bool result;
7238
7239   arg1 = (Dali::Vector4 *)jarg1;
7240   arg2 = (Dali::Vector4 *)jarg2;
7241   if (!arg2) {
7242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7243     return 0;
7244   }
7245   {
7246     try {
7247       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7248     } catch (std::out_of_range& e) {
7249       {
7250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7251       };
7252     } catch (std::exception& e) {
7253       {
7254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7255       };
7256     } catch (...) {
7257       {
7258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7259       };
7260     }
7261   }
7262   jresult = result;
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7268   float jresult ;
7269   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7270   unsigned int arg2 ;
7271   float *result = 0 ;
7272
7273   arg1 = (Dali::Vector4 *)jarg1;
7274   arg2 = (unsigned int)jarg2;
7275   {
7276     try {
7277       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7278     } catch (std::out_of_range& e) {
7279       {
7280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (std::exception& e) {
7283       {
7284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292   jresult = *result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7298   float jresult ;
7299   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7300   Dali::Vector3 *arg2 = 0 ;
7301   float result;
7302
7303   arg1 = (Dali::Vector4 *)jarg1;
7304   arg2 = (Dali::Vector3 *)jarg2;
7305   if (!arg2) {
7306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7307     return 0;
7308   }
7309   {
7310     try {
7311       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (...) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7323       };
7324     }
7325   }
7326   jresult = result;
7327   return jresult;
7328 }
7329
7330
7331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7332   float jresult ;
7333   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7334   Dali::Vector4 *arg2 = 0 ;
7335   float result;
7336
7337   arg1 = (Dali::Vector4 *)jarg1;
7338   arg2 = (Dali::Vector4 *)jarg2;
7339   if (!arg2) {
7340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7341     return 0;
7342   }
7343   {
7344     try {
7345       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7346     } catch (std::out_of_range& e) {
7347       {
7348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (std::exception& e) {
7351       {
7352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (...) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7357       };
7358     }
7359   }
7360   jresult = result;
7361   return jresult;
7362 }
7363
7364
7365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7366   float jresult ;
7367   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7368   Dali::Vector4 *arg2 = 0 ;
7369   float result;
7370
7371   arg1 = (Dali::Vector4 *)jarg1;
7372   arg2 = (Dali::Vector4 *)jarg2;
7373   if (!arg2) {
7374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7375     return 0;
7376   }
7377   {
7378     try {
7379       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7380     } catch (std::out_of_range& e) {
7381       {
7382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (std::exception& e) {
7385       {
7386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7387       };
7388     } catch (...) {
7389       {
7390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7391       };
7392     }
7393   }
7394   jresult = result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7400   void * jresult ;
7401   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7402   Dali::Vector4 *arg2 = 0 ;
7403   Dali::Vector4 result;
7404
7405   arg1 = (Dali::Vector4 *)jarg1;
7406   arg2 = (Dali::Vector4 *)jarg2;
7407   if (!arg2) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7414     } catch (std::out_of_range& e) {
7415       {
7416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (std::exception& e) {
7419       {
7420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7421       };
7422     } catch (...) {
7423       {
7424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7425       };
7426     }
7427   }
7428   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7429   return jresult;
7430 }
7431
7432
7433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7434   float jresult ;
7435   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7436   float result;
7437
7438   arg1 = (Dali::Vector4 *)jarg1;
7439   {
7440     try {
7441       result = (float)((Dali::Vector4 const *)arg1)->Length();
7442     } catch (std::out_of_range& e) {
7443       {
7444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7445       };
7446     } catch (std::exception& e) {
7447       {
7448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7449       };
7450     } catch (...) {
7451       {
7452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7453       };
7454     }
7455   }
7456   jresult = result;
7457   return jresult;
7458 }
7459
7460
7461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7462   float jresult ;
7463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7464   float result;
7465
7466   arg1 = (Dali::Vector4 *)jarg1;
7467   {
7468     try {
7469       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7470     } catch (std::out_of_range& e) {
7471       {
7472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7473       };
7474     } catch (std::exception& e) {
7475       {
7476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7477       };
7478     } catch (...) {
7479       {
7480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7481       };
7482     }
7483   }
7484   jresult = result;
7485   return jresult;
7486 }
7487
7488
7489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7490   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7491
7492   arg1 = (Dali::Vector4 *)jarg1;
7493   {
7494     try {
7495       (arg1)->Normalize();
7496     } catch (std::out_of_range& e) {
7497       {
7498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7499       };
7500     } catch (std::exception& e) {
7501       {
7502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7503       };
7504     } catch (...) {
7505       {
7506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7507       };
7508     }
7509   }
7510 }
7511
7512
7513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7514   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7515   Dali::Vector4 *arg2 = 0 ;
7516   Dali::Vector4 *arg3 = 0 ;
7517
7518   arg1 = (Dali::Vector4 *)jarg1;
7519   arg2 = (Dali::Vector4 *)jarg2;
7520   if (!arg2) {
7521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7522     return ;
7523   }
7524   arg3 = (Dali::Vector4 *)jarg3;
7525   if (!arg3) {
7526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7527     return ;
7528   }
7529   {
7530     try {
7531       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7532     } catch (std::out_of_range& e) {
7533       {
7534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7535       };
7536     } catch (std::exception& e) {
7537       {
7538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7539       };
7540     } catch (...) {
7541       {
7542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7543       };
7544     }
7545   }
7546 }
7547
7548
7549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7550   void * jresult ;
7551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7552   float *result = 0 ;
7553
7554   arg1 = (Dali::Vector4 *)jarg1;
7555   {
7556     try {
7557       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7558     } catch (std::out_of_range& e) {
7559       {
7560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7561       };
7562     } catch (std::exception& e) {
7563       {
7564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7565       };
7566     } catch (...) {
7567       {
7568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7569       };
7570     }
7571   }
7572   jresult = (void *)result;
7573   return jresult;
7574 }
7575
7576
7577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7579   float arg2 ;
7580
7581   arg1 = (Dali::Vector4 *)jarg1;
7582   arg2 = (float)jarg2;
7583   if (arg1) (arg1)->x = arg2;
7584 }
7585
7586
7587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7588   float jresult ;
7589   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7590   float result;
7591
7592   arg1 = (Dali::Vector4 *)jarg1;
7593   result = (float) ((arg1)->x);
7594   jresult = result;
7595   return jresult;
7596 }
7597
7598
7599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7600   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7601   float arg2 ;
7602
7603   arg1 = (Dali::Vector4 *)jarg1;
7604   arg2 = (float)jarg2;
7605   if (arg1) (arg1)->r = arg2;
7606 }
7607
7608
7609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7610   float jresult ;
7611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7612   float result;
7613
7614   arg1 = (Dali::Vector4 *)jarg1;
7615   result = (float) ((arg1)->r);
7616   jresult = result;
7617   return jresult;
7618 }
7619
7620
7621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7622   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7623   float arg2 ;
7624
7625   arg1 = (Dali::Vector4 *)jarg1;
7626   arg2 = (float)jarg2;
7627   if (arg1) (arg1)->s = arg2;
7628 }
7629
7630
7631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7632   float jresult ;
7633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7634   float result;
7635
7636   arg1 = (Dali::Vector4 *)jarg1;
7637   result = (float) ((arg1)->s);
7638   jresult = result;
7639   return jresult;
7640 }
7641
7642
7643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7645   float arg2 ;
7646
7647   arg1 = (Dali::Vector4 *)jarg1;
7648   arg2 = (float)jarg2;
7649   if (arg1) (arg1)->y = arg2;
7650 }
7651
7652
7653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7654   float jresult ;
7655   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7656   float result;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   result = (float) ((arg1)->y);
7660   jresult = result;
7661   return jresult;
7662 }
7663
7664
7665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7666   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7667   float arg2 ;
7668
7669   arg1 = (Dali::Vector4 *)jarg1;
7670   arg2 = (float)jarg2;
7671   if (arg1) (arg1)->g = arg2;
7672 }
7673
7674
7675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7676   float jresult ;
7677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7678   float result;
7679
7680   arg1 = (Dali::Vector4 *)jarg1;
7681   result = (float) ((arg1)->g);
7682   jresult = result;
7683   return jresult;
7684 }
7685
7686
7687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7688   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7689   float arg2 ;
7690
7691   arg1 = (Dali::Vector4 *)jarg1;
7692   arg2 = (float)jarg2;
7693   if (arg1) (arg1)->t = arg2;
7694 }
7695
7696
7697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7698   float jresult ;
7699   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7700   float result;
7701
7702   arg1 = (Dali::Vector4 *)jarg1;
7703   result = (float) ((arg1)->t);
7704   jresult = result;
7705   return jresult;
7706 }
7707
7708
7709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7710   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7711   float arg2 ;
7712
7713   arg1 = (Dali::Vector4 *)jarg1;
7714   arg2 = (float)jarg2;
7715   if (arg1) (arg1)->z = arg2;
7716 }
7717
7718
7719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7720   float jresult ;
7721   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7722   float result;
7723
7724   arg1 = (Dali::Vector4 *)jarg1;
7725   result = (float) ((arg1)->z);
7726   jresult = result;
7727   return jresult;
7728 }
7729
7730
7731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   float arg2 ;
7734
7735   arg1 = (Dali::Vector4 *)jarg1;
7736   arg2 = (float)jarg2;
7737   if (arg1) (arg1)->b = arg2;
7738 }
7739
7740
7741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7742   float jresult ;
7743   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7744   float result;
7745
7746   arg1 = (Dali::Vector4 *)jarg1;
7747   result = (float) ((arg1)->b);
7748   jresult = result;
7749   return jresult;
7750 }
7751
7752
7753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7754   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7755   float arg2 ;
7756
7757   arg1 = (Dali::Vector4 *)jarg1;
7758   arg2 = (float)jarg2;
7759   if (arg1) (arg1)->p = arg2;
7760 }
7761
7762
7763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7764   float jresult ;
7765   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7766   float result;
7767
7768   arg1 = (Dali::Vector4 *)jarg1;
7769   result = (float) ((arg1)->p);
7770   jresult = result;
7771   return jresult;
7772 }
7773
7774
7775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7777   float arg2 ;
7778
7779   arg1 = (Dali::Vector4 *)jarg1;
7780   arg2 = (float)jarg2;
7781   if (arg1) (arg1)->w = arg2;
7782 }
7783
7784
7785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7786   float jresult ;
7787   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7788   float result;
7789
7790   arg1 = (Dali::Vector4 *)jarg1;
7791   result = (float) ((arg1)->w);
7792   jresult = result;
7793   return jresult;
7794 }
7795
7796
7797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7799   float arg2 ;
7800
7801   arg1 = (Dali::Vector4 *)jarg1;
7802   arg2 = (float)jarg2;
7803   if (arg1) (arg1)->a = arg2;
7804 }
7805
7806
7807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7808   float jresult ;
7809   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7810   float result;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   result = (float) ((arg1)->a);
7814   jresult = result;
7815   return jresult;
7816 }
7817
7818
7819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7820   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7821   float arg2 ;
7822
7823   arg1 = (Dali::Vector4 *)jarg1;
7824   arg2 = (float)jarg2;
7825   if (arg1) (arg1)->q = arg2;
7826 }
7827
7828
7829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7830   float jresult ;
7831   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7832   float result;
7833
7834   arg1 = (Dali::Vector4 *)jarg1;
7835   result = (float) ((arg1)->q);
7836   jresult = result;
7837   return jresult;
7838 }
7839
7840
7841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7842   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7843
7844   arg1 = (Dali::Vector4 *)jarg1;
7845   {
7846     try {
7847       delete arg1;
7848     } catch (std::out_of_range& e) {
7849       {
7850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7851       };
7852     } catch (std::exception& e) {
7853       {
7854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7855       };
7856     } catch (...) {
7857       {
7858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7859       };
7860     }
7861   }
7862 }
7863
7864
7865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7866   void * jresult ;
7867   Dali::Vector4 *arg1 = 0 ;
7868   Dali::Vector4 *arg2 = 0 ;
7869   Dali::Vector4 result;
7870
7871   arg1 = (Dali::Vector4 *)jarg1;
7872   if (!arg1) {
7873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7874     return 0;
7875   }
7876   arg2 = (Dali::Vector4 *)jarg2;
7877   if (!arg2) {
7878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7879     return 0;
7880   }
7881   {
7882     try {
7883       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7884     } catch (std::out_of_range& e) {
7885       {
7886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7887       };
7888     } catch (std::exception& e) {
7889       {
7890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7891       };
7892     } catch (...) {
7893       {
7894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7895       };
7896     }
7897   }
7898   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7899   return jresult;
7900 }
7901
7902
7903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7904   void * jresult ;
7905   Dali::Vector4 *arg1 = 0 ;
7906   Dali::Vector4 *arg2 = 0 ;
7907   Dali::Vector4 result;
7908
7909   arg1 = (Dali::Vector4 *)jarg1;
7910   if (!arg1) {
7911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7912     return 0;
7913   }
7914   arg2 = (Dali::Vector4 *)jarg2;
7915   if (!arg2) {
7916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7917     return 0;
7918   }
7919   {
7920     try {
7921       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7922     } catch (std::out_of_range& e) {
7923       {
7924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7925       };
7926     } catch (std::exception& e) {
7927       {
7928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7929       };
7930     } catch (...) {
7931       {
7932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7933       };
7934     }
7935   }
7936   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7937   return jresult;
7938 }
7939
7940
7941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7942   void * jresult ;
7943   Dali::Vector4 *arg1 = 0 ;
7944   float *arg2 = 0 ;
7945   float *arg3 = 0 ;
7946   float temp2 ;
7947   float temp3 ;
7948   Dali::Vector4 result;
7949
7950   arg1 = (Dali::Vector4 *)jarg1;
7951   if (!arg1) {
7952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7953     return 0;
7954   }
7955   temp2 = (float)jarg2;
7956   arg2 = &temp2;
7957   temp3 = (float)jarg3;
7958   arg3 = &temp3;
7959   {
7960     try {
7961       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7962     } catch (std::out_of_range& e) {
7963       {
7964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7965       };
7966     } catch (std::exception& e) {
7967       {
7968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (...) {
7971       {
7972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7973       };
7974     }
7975   }
7976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7977   return jresult;
7978 }
7979
7980
7981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7982   void * jresult ;
7983   Dali::Uint16Pair *result = 0 ;
7984
7985   {
7986     try {
7987       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7988     } catch (std::out_of_range& e) {
7989       {
7990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7991       };
7992     } catch (std::exception& e) {
7993       {
7994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7995       };
7996     } catch (...) {
7997       {
7998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7999       };
8000     }
8001   }
8002   jresult = (void *)result;
8003   return jresult;
8004 }
8005
8006
8007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8008   void * jresult ;
8009   uint32_t arg1 ;
8010   uint32_t arg2 ;
8011   Dali::Uint16Pair *result = 0 ;
8012
8013   arg1 = (uint32_t)jarg1;
8014   arg2 = (uint32_t)jarg2;
8015   {
8016     try {
8017       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8018     } catch (std::out_of_range& e) {
8019       {
8020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8021       };
8022     } catch (std::exception& e) {
8023       {
8024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8025       };
8026     } catch (...) {
8027       {
8028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8029       };
8030     }
8031   }
8032   jresult = (void *)result;
8033   return jresult;
8034 }
8035
8036
8037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8038   void * jresult ;
8039   Dali::Uint16Pair *arg1 = 0 ;
8040   Dali::Uint16Pair *result = 0 ;
8041
8042   arg1 = (Dali::Uint16Pair *)jarg1;
8043   if (!arg1) {
8044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8045     return 0;
8046   }
8047   {
8048     try {
8049       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8050     } catch (std::out_of_range& e) {
8051       {
8052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8053       };
8054     } catch (std::exception& e) {
8055       {
8056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8057       };
8058     } catch (...) {
8059       {
8060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8061       };
8062     }
8063   }
8064   jresult = (void *)result;
8065   return jresult;
8066 }
8067
8068
8069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8070   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8071   uint16_t arg2 ;
8072
8073   arg1 = (Dali::Uint16Pair *)jarg1;
8074   arg2 = (uint16_t)jarg2;
8075   {
8076     try {
8077       (arg1)->SetWidth(arg2);
8078     } catch (std::out_of_range& e) {
8079       {
8080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8081       };
8082     } catch (std::exception& e) {
8083       {
8084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8089       };
8090     }
8091   }
8092 }
8093
8094
8095 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8096   unsigned short jresult ;
8097   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8098   uint16_t result;
8099
8100   arg1 = (Dali::Uint16Pair *)jarg1;
8101   {
8102     try {
8103       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8104     } catch (std::out_of_range& e) {
8105       {
8106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (std::exception& e) {
8109       {
8110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8111       };
8112     } catch (...) {
8113       {
8114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8115       };
8116     }
8117   }
8118   jresult = result;
8119   return jresult;
8120 }
8121
8122
8123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8124   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8125   uint16_t arg2 ;
8126
8127   arg1 = (Dali::Uint16Pair *)jarg1;
8128   arg2 = (uint16_t)jarg2;
8129   {
8130     try {
8131       (arg1)->SetHeight(arg2);
8132     } catch (std::out_of_range& e) {
8133       {
8134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8135       };
8136     } catch (std::exception& e) {
8137       {
8138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8139       };
8140     } catch (...) {
8141       {
8142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8143       };
8144     }
8145   }
8146 }
8147
8148
8149 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8150   unsigned short jresult ;
8151   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8152   uint16_t result;
8153
8154   arg1 = (Dali::Uint16Pair *)jarg1;
8155   {
8156     try {
8157       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8158     } catch (std::out_of_range& e) {
8159       {
8160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8161       };
8162     } catch (std::exception& e) {
8163       {
8164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8165       };
8166     } catch (...) {
8167       {
8168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8169       };
8170     }
8171   }
8172   jresult = result;
8173   return jresult;
8174 }
8175
8176
8177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8178   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8179   uint16_t arg2 ;
8180
8181   arg1 = (Dali::Uint16Pair *)jarg1;
8182   arg2 = (uint16_t)jarg2;
8183   {
8184     try {
8185       (arg1)->SetX(arg2);
8186     } catch (std::out_of_range& e) {
8187       {
8188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8189       };
8190     } catch (std::exception& e) {
8191       {
8192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8197       };
8198     }
8199   }
8200 }
8201
8202
8203 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8204   unsigned short jresult ;
8205   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8206   uint16_t result;
8207
8208   arg1 = (Dali::Uint16Pair *)jarg1;
8209   {
8210     try {
8211       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8212     } catch (std::out_of_range& e) {
8213       {
8214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8215       };
8216     } catch (std::exception& e) {
8217       {
8218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8219       };
8220     } catch (...) {
8221       {
8222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8223       };
8224     }
8225   }
8226   jresult = result;
8227   return jresult;
8228 }
8229
8230
8231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8232   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8233   uint16_t arg2 ;
8234
8235   arg1 = (Dali::Uint16Pair *)jarg1;
8236   arg2 = (uint16_t)jarg2;
8237   {
8238     try {
8239       (arg1)->SetY(arg2);
8240     } catch (std::out_of_range& e) {
8241       {
8242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8243       };
8244     } catch (std::exception& e) {
8245       {
8246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8247       };
8248     } catch (...) {
8249       {
8250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8251       };
8252     }
8253   }
8254 }
8255
8256
8257 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8258   unsigned short jresult ;
8259   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8260   uint16_t result;
8261
8262   arg1 = (Dali::Uint16Pair *)jarg1;
8263   {
8264     try {
8265       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8266     } catch (std::out_of_range& e) {
8267       {
8268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8269       };
8270     } catch (std::exception& e) {
8271       {
8272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8273       };
8274     } catch (...) {
8275       {
8276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8277       };
8278     }
8279   }
8280   jresult = result;
8281   return jresult;
8282 }
8283
8284
8285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8286   void * jresult ;
8287   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8288   Dali::Uint16Pair *arg2 = 0 ;
8289   Dali::Uint16Pair *result = 0 ;
8290
8291   arg1 = (Dali::Uint16Pair *)jarg1;
8292   arg2 = (Dali::Uint16Pair *)jarg2;
8293   if (!arg2) {
8294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8295     return 0;
8296   }
8297   {
8298     try {
8299       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8300     } catch (std::out_of_range& e) {
8301       {
8302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (std::exception& e) {
8305       {
8306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (...) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8311       };
8312     }
8313   }
8314   jresult = (void *)result;
8315   return jresult;
8316 }
8317
8318
8319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8320   unsigned int jresult ;
8321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8322   Dali::Uint16Pair *arg2 = 0 ;
8323   bool result;
8324
8325   arg1 = (Dali::Uint16Pair *)jarg1;
8326   arg2 = (Dali::Uint16Pair *)jarg2;
8327   if (!arg2) {
8328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8329     return 0;
8330   }
8331   {
8332     try {
8333       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8334     } catch (std::out_of_range& e) {
8335       {
8336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8337       };
8338     } catch (std::exception& e) {
8339       {
8340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8341       };
8342     } catch (...) {
8343       {
8344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8345       };
8346     }
8347   }
8348   jresult = result;
8349   return jresult;
8350 }
8351
8352
8353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8354   unsigned int jresult ;
8355   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8356   Dali::Uint16Pair *arg2 = 0 ;
8357   bool result;
8358
8359   arg1 = (Dali::Uint16Pair *)jarg1;
8360   arg2 = (Dali::Uint16Pair *)jarg2;
8361   if (!arg2) {
8362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8363     return 0;
8364   }
8365   {
8366     try {
8367       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (...) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8379       };
8380     }
8381   }
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8388   unsigned int jresult ;
8389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8390   Dali::Uint16Pair *arg2 = 0 ;
8391   bool result;
8392
8393   arg1 = (Dali::Uint16Pair *)jarg1;
8394   arg2 = (Dali::Uint16Pair *)jarg2;
8395   if (!arg2) {
8396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8397     return 0;
8398   }
8399   {
8400     try {
8401       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8402     } catch (std::out_of_range& e) {
8403       {
8404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8405       };
8406     } catch (std::exception& e) {
8407       {
8408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8409       };
8410     } catch (...) {
8411       {
8412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8413       };
8414     }
8415   }
8416   jresult = result;
8417   return jresult;
8418 }
8419
8420
8421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8422   unsigned int jresult ;
8423   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8424   Dali::Uint16Pair *arg2 = 0 ;
8425   bool result;
8426
8427   arg1 = (Dali::Uint16Pair *)jarg1;
8428   arg2 = (Dali::Uint16Pair *)jarg2;
8429   if (!arg2) {
8430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8431     return 0;
8432   }
8433   {
8434     try {
8435       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8436     } catch (std::out_of_range& e) {
8437       {
8438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8439       };
8440     } catch (std::exception& e) {
8441       {
8442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8447       };
8448     }
8449   }
8450   jresult = result;
8451   return jresult;
8452 }
8453
8454
8455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8456   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8457
8458   arg1 = (Dali::Uint16Pair *)jarg1;
8459   {
8460     try {
8461       delete arg1;
8462     } catch (std::out_of_range& e) {
8463       {
8464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8465       };
8466     } catch (std::exception& e) {
8467       {
8468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8469       };
8470     } catch (...) {
8471       {
8472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8473       };
8474     }
8475   }
8476 }
8477
8478
8479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8480   void * jresult ;
8481   Dali::Degree *result = 0 ;
8482
8483   {
8484     try {
8485       result = (Dali::Degree *)new Dali::Degree();
8486     } catch (std::out_of_range& e) {
8487       {
8488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8489       };
8490     } catch (std::exception& e) {
8491       {
8492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8493       };
8494     } catch (...) {
8495       {
8496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8497       };
8498     }
8499   }
8500   jresult = (void *)result;
8501   return jresult;
8502 }
8503
8504
8505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8506   void * jresult ;
8507   float arg1 ;
8508   Dali::Degree *result = 0 ;
8509
8510   arg1 = (float)jarg1;
8511   {
8512     try {
8513       result = (Dali::Degree *)new Dali::Degree(arg1);
8514     } catch (std::out_of_range& e) {
8515       {
8516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (std::exception& e) {
8519       {
8520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528   jresult = (void *)result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8534   void * jresult ;
8535   Dali::Radian arg1 ;
8536   Dali::Radian *argp1 ;
8537   Dali::Degree *result = 0 ;
8538
8539   argp1 = (Dali::Radian *)jarg1;
8540   if (!argp1) {
8541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8542     return 0;
8543   }
8544   arg1 = *argp1;
8545   {
8546     try {
8547       result = (Dali::Degree *)new Dali::Degree(arg1);
8548     } catch (std::out_of_range& e) {
8549       {
8550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8551       };
8552     } catch (std::exception& e) {
8553       {
8554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8555       };
8556     } catch (...) {
8557       {
8558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8559       };
8560     }
8561   }
8562   jresult = (void *)result;
8563   return jresult;
8564 }
8565
8566
8567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8568   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8569   float arg2 ;
8570
8571   arg1 = (Dali::Degree *)jarg1;
8572   arg2 = (float)jarg2;
8573   if (arg1) (arg1)->degree = arg2;
8574 }
8575
8576
8577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8578   float jresult ;
8579   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8580   float result;
8581
8582   arg1 = (Dali::Degree *)jarg1;
8583   result = (float) ((arg1)->degree);
8584   jresult = result;
8585   return jresult;
8586 }
8587
8588
8589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8590   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8591
8592   arg1 = (Dali::Degree *)jarg1;
8593   {
8594     try {
8595       delete arg1;
8596     } catch (std::out_of_range& e) {
8597       {
8598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8599       };
8600     } catch (std::exception& e) {
8601       {
8602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8603       };
8604     } catch (...) {
8605       {
8606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8607       };
8608     }
8609   }
8610 }
8611
8612
8613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8614   void * jresult ;
8615   Dali::Radian *result = 0 ;
8616
8617   result = (Dali::Radian *)&Dali::ANGLE_360;
8618   jresult = (void *)result;
8619   return jresult;
8620 }
8621
8622
8623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8624   void * jresult ;
8625   Dali::Radian *result = 0 ;
8626
8627   result = (Dali::Radian *)&Dali::ANGLE_315;
8628   jresult = (void *)result;
8629   return jresult;
8630 }
8631
8632
8633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8634   void * jresult ;
8635   Dali::Radian *result = 0 ;
8636
8637   result = (Dali::Radian *)&Dali::ANGLE_270;
8638   jresult = (void *)result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8644   void * jresult ;
8645   Dali::Radian *result = 0 ;
8646
8647   result = (Dali::Radian *)&Dali::ANGLE_225;
8648   jresult = (void *)result;
8649   return jresult;
8650 }
8651
8652
8653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8654   void * jresult ;
8655   Dali::Radian *result = 0 ;
8656
8657   result = (Dali::Radian *)&Dali::ANGLE_180;
8658   jresult = (void *)result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8664   void * jresult ;
8665   Dali::Radian *result = 0 ;
8666
8667   result = (Dali::Radian *)&Dali::ANGLE_135;
8668   jresult = (void *)result;
8669   return jresult;
8670 }
8671
8672
8673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8674   void * jresult ;
8675   Dali::Radian *result = 0 ;
8676
8677   result = (Dali::Radian *)&Dali::ANGLE_120;
8678   jresult = (void *)result;
8679   return jresult;
8680 }
8681
8682
8683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8684   void * jresult ;
8685   Dali::Radian *result = 0 ;
8686
8687   result = (Dali::Radian *)&Dali::ANGLE_90;
8688   jresult = (void *)result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8694   void * jresult ;
8695   Dali::Radian *result = 0 ;
8696
8697   result = (Dali::Radian *)&Dali::ANGLE_60;
8698   jresult = (void *)result;
8699   return jresult;
8700 }
8701
8702
8703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8704   void * jresult ;
8705   Dali::Radian *result = 0 ;
8706
8707   result = (Dali::Radian *)&Dali::ANGLE_45;
8708   jresult = (void *)result;
8709   return jresult;
8710 }
8711
8712
8713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8714   void * jresult ;
8715   Dali::Radian *result = 0 ;
8716
8717   result = (Dali::Radian *)&Dali::ANGLE_30;
8718   jresult = (void *)result;
8719   return jresult;
8720 }
8721
8722
8723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8724   void * jresult ;
8725   Dali::Radian *result = 0 ;
8726
8727   result = (Dali::Radian *)&Dali::ANGLE_0;
8728   jresult = (void *)result;
8729   return jresult;
8730 }
8731
8732
8733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8734   unsigned int jresult ;
8735   Dali::Degree *arg1 = 0 ;
8736   Dali::Degree *arg2 = 0 ;
8737   bool result;
8738
8739   arg1 = (Dali::Degree *)jarg1;
8740   if (!arg1) {
8741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8742     return 0;
8743   }
8744   arg2 = (Dali::Degree *)jarg2;
8745   if (!arg2) {
8746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8747     return 0;
8748   }
8749   {
8750     try {
8751       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8752     } catch (std::out_of_range& e) {
8753       {
8754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8755       };
8756     } catch (std::exception& e) {
8757       {
8758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8759       };
8760     } catch (...) {
8761       {
8762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8763       };
8764     }
8765   }
8766   jresult = result;
8767   return jresult;
8768 }
8769
8770
8771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8772   unsigned int jresult ;
8773   Dali::Degree *arg1 = 0 ;
8774   Dali::Degree *arg2 = 0 ;
8775   bool result;
8776
8777   arg1 = (Dali::Degree *)jarg1;
8778   if (!arg1) {
8779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8780     return 0;
8781   }
8782   arg2 = (Dali::Degree *)jarg2;
8783   if (!arg2) {
8784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8785     return 0;
8786   }
8787   {
8788     try {
8789       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8790     } catch (std::out_of_range& e) {
8791       {
8792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8793       };
8794     } catch (std::exception& e) {
8795       {
8796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8797       };
8798     } catch (...) {
8799       {
8800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8801       };
8802     }
8803   }
8804   jresult = result;
8805   return jresult;
8806 }
8807
8808
8809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8810   void * jresult ;
8811   Dali::Degree arg1 ;
8812   float arg2 ;
8813   float arg3 ;
8814   Dali::Degree *argp1 ;
8815   Dali::Degree result;
8816
8817   argp1 = (Dali::Degree *)jarg1;
8818   if (!argp1) {
8819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8820     return 0;
8821   }
8822   arg1 = *argp1;
8823   arg2 = (float)jarg2;
8824   arg3 = (float)jarg3;
8825   {
8826     try {
8827       result = Dali::Clamp(arg1,arg2,arg3);
8828     } catch (std::out_of_range& e) {
8829       {
8830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8831       };
8832     } catch (std::exception& e) {
8833       {
8834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8835       };
8836     } catch (...) {
8837       {
8838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8839       };
8840     }
8841   }
8842   jresult = new Dali::Degree((const Dali::Degree &)result);
8843   return jresult;
8844 }
8845
8846
8847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8848   void * jresult ;
8849   Dali::Radian *result = 0 ;
8850
8851   {
8852     try {
8853       result = (Dali::Radian *)new Dali::Radian();
8854     } catch (std::out_of_range& e) {
8855       {
8856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8857       };
8858     } catch (std::exception& e) {
8859       {
8860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (...) {
8863       {
8864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8865       };
8866     }
8867   }
8868   jresult = (void *)result;
8869   return jresult;
8870 }
8871
8872
8873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8874   void * jresult ;
8875   float arg1 ;
8876   Dali::Radian *result = 0 ;
8877
8878   arg1 = (float)jarg1;
8879   {
8880     try {
8881       result = (Dali::Radian *)new Dali::Radian(arg1);
8882     } catch (std::out_of_range& e) {
8883       {
8884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8885       };
8886     } catch (std::exception& e) {
8887       {
8888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8889       };
8890     } catch (...) {
8891       {
8892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8893       };
8894     }
8895   }
8896   jresult = (void *)result;
8897   return jresult;
8898 }
8899
8900
8901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8902   void * jresult ;
8903   Dali::Degree arg1 ;
8904   Dali::Degree *argp1 ;
8905   Dali::Radian *result = 0 ;
8906
8907   argp1 = (Dali::Degree *)jarg1;
8908   if (!argp1) {
8909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8910     return 0;
8911   }
8912   arg1 = *argp1;
8913   {
8914     try {
8915       result = (Dali::Radian *)new Dali::Radian(arg1);
8916     } catch (std::out_of_range& e) {
8917       {
8918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8919       };
8920     } catch (std::exception& e) {
8921       {
8922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (...) {
8925       {
8926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8927       };
8928     }
8929   }
8930   jresult = (void *)result;
8931   return jresult;
8932 }
8933
8934
8935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8936   void * jresult ;
8937   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8938   float arg2 ;
8939   Dali::Radian *result = 0 ;
8940
8941   arg1 = (Dali::Radian *)jarg1;
8942   arg2 = (float)jarg2;
8943   {
8944     try {
8945       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8946     } catch (std::out_of_range& e) {
8947       {
8948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8949       };
8950     } catch (std::exception& e) {
8951       {
8952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8953       };
8954     } catch (...) {
8955       {
8956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8957       };
8958     }
8959   }
8960   jresult = (void *)result;
8961   return jresult;
8962 }
8963
8964
8965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8966   void * jresult ;
8967   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8968   Dali::Degree arg2 ;
8969   Dali::Degree *argp2 ;
8970   Dali::Radian *result = 0 ;
8971
8972   arg1 = (Dali::Radian *)jarg1;
8973   argp2 = (Dali::Degree *)jarg2;
8974   if (!argp2) {
8975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8976     return 0;
8977   }
8978   arg2 = *argp2;
8979   {
8980     try {
8981       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8982     } catch (std::out_of_range& e) {
8983       {
8984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8985       };
8986     } catch (std::exception& e) {
8987       {
8988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8989       };
8990     } catch (...) {
8991       {
8992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8993       };
8994     }
8995   }
8996   jresult = (void *)result;
8997   return jresult;
8998 }
8999
9000
9001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9002   float jresult ;
9003   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9004   float result;
9005
9006   arg1 = (Dali::Radian *)jarg1;
9007   {
9008     try {
9009       result = (float)((Dali::Radian const *)arg1)->operator float();
9010     } catch (std::out_of_range& e) {
9011       {
9012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9013       };
9014     } catch (std::exception& e) {
9015       {
9016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9017       };
9018     } catch (...) {
9019       {
9020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9021       };
9022     }
9023   }
9024   jresult = result;
9025   return jresult;
9026 }
9027
9028
9029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9030   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9031   float arg2 ;
9032
9033   arg1 = (Dali::Radian *)jarg1;
9034   arg2 = (float)jarg2;
9035   if (arg1) (arg1)->radian = arg2;
9036 }
9037
9038
9039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9040   float jresult ;
9041   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9042   float result;
9043
9044   arg1 = (Dali::Radian *)jarg1;
9045   result = (float) ((arg1)->radian);
9046   jresult = result;
9047   return jresult;
9048 }
9049
9050
9051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9052   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9053
9054   arg1 = (Dali::Radian *)jarg1;
9055   {
9056     try {
9057       delete arg1;
9058     } catch (std::out_of_range& e) {
9059       {
9060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9061       };
9062     } catch (std::exception& e) {
9063       {
9064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9065       };
9066     } catch (...) {
9067       {
9068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9069       };
9070     }
9071   }
9072 }
9073
9074
9075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9076   unsigned int jresult ;
9077   Dali::Radian arg1 ;
9078   Dali::Radian arg2 ;
9079   Dali::Radian *argp1 ;
9080   Dali::Radian *argp2 ;
9081   bool result;
9082
9083   argp1 = (Dali::Radian *)jarg1;
9084   if (!argp1) {
9085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9086     return 0;
9087   }
9088   arg1 = *argp1;
9089   argp2 = (Dali::Radian *)jarg2;
9090   if (!argp2) {
9091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9092     return 0;
9093   }
9094   arg2 = *argp2;
9095   {
9096     try {
9097       result = (bool)Dali::operator ==(arg1,arg2);
9098     } catch (std::out_of_range& e) {
9099       {
9100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9101       };
9102     } catch (std::exception& e) {
9103       {
9104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9105       };
9106     } catch (...) {
9107       {
9108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9109       };
9110     }
9111   }
9112   jresult = result;
9113   return jresult;
9114 }
9115
9116
9117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9118   unsigned int jresult ;
9119   Dali::Radian arg1 ;
9120   Dali::Radian arg2 ;
9121   Dali::Radian *argp1 ;
9122   Dali::Radian *argp2 ;
9123   bool result;
9124
9125   argp1 = (Dali::Radian *)jarg1;
9126   if (!argp1) {
9127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9128     return 0;
9129   }
9130   arg1 = *argp1;
9131   argp2 = (Dali::Radian *)jarg2;
9132   if (!argp2) {
9133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9134     return 0;
9135   }
9136   arg2 = *argp2;
9137   {
9138     try {
9139       result = (bool)Dali::operator !=(arg1,arg2);
9140     } catch (std::out_of_range& e) {
9141       {
9142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9143       };
9144     } catch (std::exception& e) {
9145       {
9146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9151       };
9152     }
9153   }
9154   jresult = result;
9155   return jresult;
9156 }
9157
9158
9159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9160   unsigned int jresult ;
9161   Dali::Radian arg1 ;
9162   Dali::Degree arg2 ;
9163   Dali::Radian *argp1 ;
9164   Dali::Degree *argp2 ;
9165   bool result;
9166
9167   argp1 = (Dali::Radian *)jarg1;
9168   if (!argp1) {
9169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9170     return 0;
9171   }
9172   arg1 = *argp1;
9173   argp2 = (Dali::Degree *)jarg2;
9174   if (!argp2) {
9175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9176     return 0;
9177   }
9178   arg2 = *argp2;
9179   {
9180     try {
9181       result = (bool)Dali::operator ==(arg1,arg2);
9182     } catch (std::out_of_range& e) {
9183       {
9184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9185       };
9186     } catch (std::exception& e) {
9187       {
9188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9189       };
9190     } catch (...) {
9191       {
9192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9193       };
9194     }
9195   }
9196   jresult = result;
9197   return jresult;
9198 }
9199
9200
9201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9202   unsigned int jresult ;
9203   Dali::Radian arg1 ;
9204   Dali::Degree arg2 ;
9205   Dali::Radian *argp1 ;
9206   Dali::Degree *argp2 ;
9207   bool result;
9208
9209   argp1 = (Dali::Radian *)jarg1;
9210   if (!argp1) {
9211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9212     return 0;
9213   }
9214   arg1 = *argp1;
9215   argp2 = (Dali::Degree *)jarg2;
9216   if (!argp2) {
9217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9218     return 0;
9219   }
9220   arg2 = *argp2;
9221   {
9222     try {
9223       result = (bool)Dali::operator !=(arg1,arg2);
9224     } catch (std::out_of_range& e) {
9225       {
9226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9227       };
9228     } catch (std::exception& e) {
9229       {
9230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9231       };
9232     } catch (...) {
9233       {
9234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9235       };
9236     }
9237   }
9238   jresult = result;
9239   return jresult;
9240 }
9241
9242
9243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9244   unsigned int jresult ;
9245   Dali::Degree arg1 ;
9246   Dali::Radian arg2 ;
9247   Dali::Degree *argp1 ;
9248   Dali::Radian *argp2 ;
9249   bool result;
9250
9251   argp1 = (Dali::Degree *)jarg1;
9252   if (!argp1) {
9253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9254     return 0;
9255   }
9256   arg1 = *argp1;
9257   argp2 = (Dali::Radian *)jarg2;
9258   if (!argp2) {
9259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9260     return 0;
9261   }
9262   arg2 = *argp2;
9263   {
9264     try {
9265       result = (bool)Dali::operator ==(arg1,arg2);
9266     } catch (std::out_of_range& e) {
9267       {
9268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9269       };
9270     } catch (std::exception& e) {
9271       {
9272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9277       };
9278     }
9279   }
9280   jresult = result;
9281   return jresult;
9282 }
9283
9284
9285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9286   unsigned int jresult ;
9287   Dali::Degree arg1 ;
9288   Dali::Radian arg2 ;
9289   Dali::Degree *argp1 ;
9290   Dali::Radian *argp2 ;
9291   bool result;
9292
9293   argp1 = (Dali::Degree *)jarg1;
9294   if (!argp1) {
9295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9296     return 0;
9297   }
9298   arg1 = *argp1;
9299   argp2 = (Dali::Radian *)jarg2;
9300   if (!argp2) {
9301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9302     return 0;
9303   }
9304   arg2 = *argp2;
9305   {
9306     try {
9307       result = (bool)Dali::operator !=(arg1,arg2);
9308     } catch (std::out_of_range& e) {
9309       {
9310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9311       };
9312     } catch (std::exception& e) {
9313       {
9314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9315       };
9316     } catch (...) {
9317       {
9318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9319       };
9320     }
9321   }
9322   jresult = result;
9323   return jresult;
9324 }
9325
9326
9327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9328   unsigned int jresult ;
9329   Dali::Radian arg1 ;
9330   Dali::Radian arg2 ;
9331   Dali::Radian *argp1 ;
9332   Dali::Radian *argp2 ;
9333   bool result;
9334
9335   argp1 = (Dali::Radian *)jarg1;
9336   if (!argp1) {
9337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9338     return 0;
9339   }
9340   arg1 = *argp1;
9341   argp2 = (Dali::Radian *)jarg2;
9342   if (!argp2) {
9343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9344     return 0;
9345   }
9346   arg2 = *argp2;
9347   {
9348     try {
9349       result = (bool)Dali::operator >(arg1,arg2);
9350     } catch (std::out_of_range& e) {
9351       {
9352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9353       };
9354     } catch (std::exception& e) {
9355       {
9356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9357       };
9358     } catch (...) {
9359       {
9360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9361       };
9362     }
9363   }
9364   jresult = result;
9365   return jresult;
9366 }
9367
9368
9369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9370   unsigned int jresult ;
9371   Dali::Radian arg1 ;
9372   Dali::Degree arg2 ;
9373   Dali::Radian *argp1 ;
9374   Dali::Degree *argp2 ;
9375   bool result;
9376
9377   argp1 = (Dali::Radian *)jarg1;
9378   if (!argp1) {
9379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9380     return 0;
9381   }
9382   arg1 = *argp1;
9383   argp2 = (Dali::Degree *)jarg2;
9384   if (!argp2) {
9385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9386     return 0;
9387   }
9388   arg2 = *argp2;
9389   {
9390     try {
9391       result = (bool)Dali::operator >(arg1,arg2);
9392     } catch (std::out_of_range& e) {
9393       {
9394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9395       };
9396     } catch (std::exception& e) {
9397       {
9398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9399       };
9400     } catch (...) {
9401       {
9402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9403       };
9404     }
9405   }
9406   jresult = result;
9407   return jresult;
9408 }
9409
9410
9411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9412   unsigned int jresult ;
9413   Dali::Degree arg1 ;
9414   Dali::Radian arg2 ;
9415   Dali::Degree *argp1 ;
9416   Dali::Radian *argp2 ;
9417   bool result;
9418
9419   argp1 = (Dali::Degree *)jarg1;
9420   if (!argp1) {
9421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9422     return 0;
9423   }
9424   arg1 = *argp1;
9425   argp2 = (Dali::Radian *)jarg2;
9426   if (!argp2) {
9427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9428     return 0;
9429   }
9430   arg2 = *argp2;
9431   {
9432     try {
9433       result = (bool)Dali::operator >(arg1,arg2);
9434     } catch (std::out_of_range& e) {
9435       {
9436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9437       };
9438     } catch (std::exception& e) {
9439       {
9440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9441       };
9442     } catch (...) {
9443       {
9444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9445       };
9446     }
9447   }
9448   jresult = result;
9449   return jresult;
9450 }
9451
9452
9453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9454   unsigned int jresult ;
9455   Dali::Radian arg1 ;
9456   Dali::Radian arg2 ;
9457   Dali::Radian *argp1 ;
9458   Dali::Radian *argp2 ;
9459   bool result;
9460
9461   argp1 = (Dali::Radian *)jarg1;
9462   if (!argp1) {
9463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9464     return 0;
9465   }
9466   arg1 = *argp1;
9467   argp2 = (Dali::Radian *)jarg2;
9468   if (!argp2) {
9469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9470     return 0;
9471   }
9472   arg2 = *argp2;
9473   {
9474     try {
9475       result = (bool)Dali::operator <(arg1,arg2);
9476     } catch (std::out_of_range& e) {
9477       {
9478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9479       };
9480     } catch (std::exception& e) {
9481       {
9482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9483       };
9484     } catch (...) {
9485       {
9486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9487       };
9488     }
9489   }
9490   jresult = result;
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9496   unsigned int jresult ;
9497   Dali::Radian arg1 ;
9498   Dali::Degree arg2 ;
9499   Dali::Radian *argp1 ;
9500   Dali::Degree *argp2 ;
9501   bool result;
9502
9503   argp1 = (Dali::Radian *)jarg1;
9504   if (!argp1) {
9505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9506     return 0;
9507   }
9508   arg1 = *argp1;
9509   argp2 = (Dali::Degree *)jarg2;
9510   if (!argp2) {
9511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9512     return 0;
9513   }
9514   arg2 = *argp2;
9515   {
9516     try {
9517       result = (bool)Dali::operator <(arg1,arg2);
9518     } catch (std::out_of_range& e) {
9519       {
9520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9521       };
9522     } catch (std::exception& e) {
9523       {
9524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9525       };
9526     } catch (...) {
9527       {
9528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9529       };
9530     }
9531   }
9532   jresult = result;
9533   return jresult;
9534 }
9535
9536
9537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9538   unsigned int jresult ;
9539   Dali::Degree arg1 ;
9540   Dali::Radian arg2 ;
9541   Dali::Degree *argp1 ;
9542   Dali::Radian *argp2 ;
9543   bool result;
9544
9545   argp1 = (Dali::Degree *)jarg1;
9546   if (!argp1) {
9547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9548     return 0;
9549   }
9550   arg1 = *argp1;
9551   argp2 = (Dali::Radian *)jarg2;
9552   if (!argp2) {
9553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9554     return 0;
9555   }
9556   arg2 = *argp2;
9557   {
9558     try {
9559       result = (bool)Dali::operator <(arg1,arg2);
9560     } catch (std::out_of_range& e) {
9561       {
9562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9563       };
9564     } catch (std::exception& e) {
9565       {
9566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9567       };
9568     } catch (...) {
9569       {
9570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9571       };
9572     }
9573   }
9574   jresult = result;
9575   return jresult;
9576 }
9577
9578
9579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9580   void * jresult ;
9581   Dali::Radian arg1 ;
9582   float arg2 ;
9583   Dali::Radian *argp1 ;
9584   Dali::Radian result;
9585
9586   argp1 = (Dali::Radian *)jarg1;
9587   if (!argp1) {
9588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9589     return 0;
9590   }
9591   arg1 = *argp1;
9592   arg2 = (float)jarg2;
9593   {
9594     try {
9595       result = Dali::operator *(arg1,arg2);
9596     } catch (std::out_of_range& e) {
9597       {
9598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9599       };
9600     } catch (std::exception& e) {
9601       {
9602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9603       };
9604     } catch (...) {
9605       {
9606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9607       };
9608     }
9609   }
9610   jresult = new Dali::Radian((const Dali::Radian &)result);
9611   return jresult;
9612 }
9613
9614
9615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9616   void * jresult ;
9617   Dali::Radian arg1 ;
9618   Dali::Radian *argp1 ;
9619   Dali::Radian result;
9620
9621   argp1 = (Dali::Radian *)jarg1;
9622   if (!argp1) {
9623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9624     return 0;
9625   }
9626   arg1 = *argp1;
9627   {
9628     try {
9629       result = Dali::operator -(arg1);
9630     } catch (std::out_of_range& e) {
9631       {
9632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9633       };
9634     } catch (std::exception& e) {
9635       {
9636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9637       };
9638     } catch (...) {
9639       {
9640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9641       };
9642     }
9643   }
9644   jresult = new Dali::Radian((const Dali::Radian &)result);
9645   return jresult;
9646 }
9647
9648
9649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9650   void * jresult ;
9651   Dali::Radian arg1 ;
9652   float arg2 ;
9653   float arg3 ;
9654   Dali::Radian *argp1 ;
9655   Dali::Radian result;
9656
9657   argp1 = (Dali::Radian *)jarg1;
9658   if (!argp1) {
9659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9660     return 0;
9661   }
9662   arg1 = *argp1;
9663   arg2 = (float)jarg2;
9664   arg3 = (float)jarg3;
9665   {
9666     try {
9667       result = Dali::Clamp(arg1,arg2,arg3);
9668     } catch (std::out_of_range& e) {
9669       {
9670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9671       };
9672     } catch (std::exception& e) {
9673       {
9674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9675       };
9676     } catch (...) {
9677       {
9678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9679       };
9680     }
9681   }
9682   jresult = new Dali::Radian((const Dali::Radian &)result);
9683   return jresult;
9684 }
9685
9686
9687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9688   void * jresult ;
9689   Dali::Quaternion *result = 0 ;
9690
9691   {
9692     try {
9693       result = (Dali::Quaternion *)new Dali::Quaternion();
9694     } catch (std::out_of_range& e) {
9695       {
9696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9697       };
9698     } catch (std::exception& e) {
9699       {
9700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (...) {
9703       {
9704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9705       };
9706     }
9707   }
9708   jresult = (void *)result;
9709   return jresult;
9710 }
9711
9712
9713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9714   void * jresult ;
9715   Dali::Radian arg1 ;
9716   Dali::Vector3 *arg2 = 0 ;
9717   Dali::Radian *argp1 ;
9718   Dali::Quaternion *result = 0 ;
9719
9720   argp1 = (Dali::Radian *)jarg1;
9721   if (!argp1) {
9722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9723     return 0;
9724   }
9725   arg1 = *argp1;
9726   arg2 = (Dali::Vector3 *)jarg2;
9727   if (!arg2) {
9728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9729     return 0;
9730   }
9731   {
9732     try {
9733       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9734     } catch (std::out_of_range& e) {
9735       {
9736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9737       };
9738     } catch (std::exception& e) {
9739       {
9740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9741       };
9742     } catch (...) {
9743       {
9744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9745       };
9746     }
9747   }
9748   jresult = (void *)result;
9749   return jresult;
9750 }
9751
9752
9753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9754   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9755
9756   arg1 = (Dali::Quaternion *)jarg1;
9757   {
9758     try {
9759       delete arg1;
9760     } catch (std::out_of_range& e) {
9761       {
9762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9763       };
9764     } catch (std::exception& e) {
9765       {
9766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9767       };
9768     } catch (...) {
9769       {
9770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9771       };
9772     }
9773   }
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9778   void * jresult ;
9779   Dali::Quaternion *result = 0 ;
9780
9781   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9788   unsigned int jresult ;
9789   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9790   bool result;
9791
9792   arg1 = (Dali::Quaternion *)jarg1;
9793   {
9794     try {
9795       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9796     } catch (std::out_of_range& e) {
9797       {
9798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9799       };
9800     } catch (std::exception& e) {
9801       {
9802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9803       };
9804     } catch (...) {
9805       {
9806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9807       };
9808     }
9809   }
9810   jresult = result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9816   unsigned int jresult ;
9817   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9818   Dali::Vector3 *arg2 = 0 ;
9819   Dali::Radian *arg3 = 0 ;
9820   bool result;
9821
9822   arg1 = (Dali::Quaternion *)jarg1;
9823   arg2 = (Dali::Vector3 *)jarg2;
9824   if (!arg2) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9826     return 0;
9827   }
9828   arg3 = (Dali::Radian *)jarg3;
9829   if (!arg3) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850   jresult = result;
9851   return jresult;
9852 }
9853
9854
9855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9856   void * jresult ;
9857   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9858   Dali::Quaternion *arg2 = 0 ;
9859   Dali::Quaternion result;
9860
9861   arg1 = (Dali::Quaternion *)jarg1;
9862   arg2 = (Dali::Quaternion *)jarg2;
9863   if (!arg2) {
9864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9865     return 0;
9866   }
9867   {
9868     try {
9869       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9870     } catch (std::out_of_range& e) {
9871       {
9872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9873       };
9874     } catch (std::exception& e) {
9875       {
9876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9877       };
9878     } catch (...) {
9879       {
9880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9881       };
9882     }
9883   }
9884   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9885   return jresult;
9886 }
9887
9888
9889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9890   void * jresult ;
9891   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9892   Dali::Quaternion *arg2 = 0 ;
9893   Dali::Quaternion result;
9894
9895   arg1 = (Dali::Quaternion *)jarg1;
9896   arg2 = (Dali::Quaternion *)jarg2;
9897   if (!arg2) {
9898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9899     return 0;
9900   }
9901   {
9902     try {
9903       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9904     } catch (std::out_of_range& e) {
9905       {
9906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9907       };
9908     } catch (std::exception& e) {
9909       {
9910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9911       };
9912     } catch (...) {
9913       {
9914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9915       };
9916     }
9917   }
9918   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9919   return jresult;
9920 }
9921
9922
9923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9924   void * jresult ;
9925   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9926   Dali::Quaternion *arg2 = 0 ;
9927   Dali::Quaternion result;
9928
9929   arg1 = (Dali::Quaternion *)jarg1;
9930   arg2 = (Dali::Quaternion *)jarg2;
9931   if (!arg2) {
9932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9933     return 0;
9934   }
9935   {
9936     try {
9937       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9938     } catch (std::out_of_range& e) {
9939       {
9940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (std::exception& e) {
9943       {
9944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9945       };
9946     } catch (...) {
9947       {
9948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9949       };
9950     }
9951   }
9952   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9953   return jresult;
9954 }
9955
9956
9957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9958   void * jresult ;
9959   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9960   Dali::Vector3 *arg2 = 0 ;
9961   Dali::Vector3 result;
9962
9963   arg1 = (Dali::Quaternion *)jarg1;
9964   arg2 = (Dali::Vector3 *)jarg2;
9965   if (!arg2) {
9966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9967     return 0;
9968   }
9969   {
9970     try {
9971       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9972     } catch (std::out_of_range& e) {
9973       {
9974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9975       };
9976     } catch (std::exception& e) {
9977       {
9978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (...) {
9981       {
9982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9983       };
9984     }
9985   }
9986   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
9992   void * jresult ;
9993   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9994   Dali::Quaternion *arg2 = 0 ;
9995   Dali::Quaternion result;
9996
9997   arg1 = (Dali::Quaternion *)jarg1;
9998   arg2 = (Dali::Quaternion *)jarg2;
9999   if (!arg2) {
10000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10001     return 0;
10002   }
10003   {
10004     try {
10005       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10006     } catch (std::out_of_range& e) {
10007       {
10008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10009       };
10010     } catch (std::exception& e) {
10011       {
10012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10013       };
10014     } catch (...) {
10015       {
10016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10017       };
10018     }
10019   }
10020   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10026   void * jresult ;
10027   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10028   float arg2 ;
10029   Dali::Quaternion result;
10030
10031   arg1 = (Dali::Quaternion *)jarg1;
10032   arg2 = (float)jarg2;
10033   {
10034     try {
10035       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10036     } catch (std::out_of_range& e) {
10037       {
10038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10039       };
10040     } catch (std::exception& e) {
10041       {
10042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (...) {
10045       {
10046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10047       };
10048     }
10049   }
10050   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10051   return jresult;
10052 }
10053
10054
10055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10056   void * jresult ;
10057   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10058   float arg2 ;
10059   Dali::Quaternion result;
10060
10061   arg1 = (Dali::Quaternion *)jarg1;
10062   arg2 = (float)jarg2;
10063   {
10064     try {
10065       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10066     } catch (std::out_of_range& e) {
10067       {
10068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10069       };
10070     } catch (std::exception& e) {
10071       {
10072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10073       };
10074     } catch (...) {
10075       {
10076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10077       };
10078     }
10079   }
10080   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10081   return jresult;
10082 }
10083
10084
10085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10086   void * jresult ;
10087   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10088   Dali::Quaternion result;
10089
10090   arg1 = (Dali::Quaternion *)jarg1;
10091   {
10092     try {
10093       result = ((Dali::Quaternion const *)arg1)->operator -();
10094     } catch (std::out_of_range& e) {
10095       {
10096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10097       };
10098     } catch (std::exception& e) {
10099       {
10100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10101       };
10102     } catch (...) {
10103       {
10104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10105       };
10106     }
10107   }
10108   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10109   return jresult;
10110 }
10111
10112
10113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10114   void * jresult ;
10115   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10116   Dali::Quaternion *arg2 = 0 ;
10117   Dali::Quaternion *result = 0 ;
10118
10119   arg1 = (Dali::Quaternion *)jarg1;
10120   arg2 = (Dali::Quaternion *)jarg2;
10121   if (!arg2) {
10122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10123     return 0;
10124   }
10125   {
10126     try {
10127       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10128     } catch (std::out_of_range& e) {
10129       {
10130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10131       };
10132     } catch (std::exception& e) {
10133       {
10134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (...) {
10137       {
10138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10139       };
10140     }
10141   }
10142   jresult = (void *)result;
10143   return jresult;
10144 }
10145
10146
10147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10148   void * jresult ;
10149   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10150   Dali::Quaternion *arg2 = 0 ;
10151   Dali::Quaternion *result = 0 ;
10152
10153   arg1 = (Dali::Quaternion *)jarg1;
10154   arg2 = (Dali::Quaternion *)jarg2;
10155   if (!arg2) {
10156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10157     return 0;
10158   }
10159   {
10160     try {
10161       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10162     } catch (std::out_of_range& e) {
10163       {
10164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10165       };
10166     } catch (std::exception& e) {
10167       {
10168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10169       };
10170     } catch (...) {
10171       {
10172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10173       };
10174     }
10175   }
10176   jresult = (void *)result;
10177   return jresult;
10178 }
10179
10180
10181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10182   void * jresult ;
10183   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10184   Dali::Quaternion *arg2 = 0 ;
10185   Dali::Quaternion *result = 0 ;
10186
10187   arg1 = (Dali::Quaternion *)jarg1;
10188   arg2 = (Dali::Quaternion *)jarg2;
10189   if (!arg2) {
10190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10191     return 0;
10192   }
10193   {
10194     try {
10195       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10196     } catch (std::out_of_range& e) {
10197       {
10198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (std::exception& e) {
10201       {
10202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10207       };
10208     }
10209   }
10210   jresult = (void *)result;
10211   return jresult;
10212 }
10213
10214
10215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10216   void * jresult ;
10217   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10218   float arg2 ;
10219   Dali::Quaternion *result = 0 ;
10220
10221   arg1 = (Dali::Quaternion *)jarg1;
10222   arg2 = (float)jarg2;
10223   {
10224     try {
10225       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10226     } catch (std::out_of_range& e) {
10227       {
10228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10229       };
10230     } catch (std::exception& e) {
10231       {
10232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (...) {
10235       {
10236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10237       };
10238     }
10239   }
10240   jresult = (void *)result;
10241   return jresult;
10242 }
10243
10244
10245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10246   void * jresult ;
10247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10248   float arg2 ;
10249   Dali::Quaternion *result = 0 ;
10250
10251   arg1 = (Dali::Quaternion *)jarg1;
10252   arg2 = (float)jarg2;
10253   {
10254     try {
10255       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10256     } catch (std::out_of_range& e) {
10257       {
10258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10259       };
10260     } catch (std::exception& e) {
10261       {
10262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10263       };
10264     } catch (...) {
10265       {
10266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10267       };
10268     }
10269   }
10270   jresult = (void *)result;
10271   return jresult;
10272 }
10273
10274
10275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10276   unsigned int jresult ;
10277   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10278   Dali::Quaternion *arg2 = 0 ;
10279   bool result;
10280
10281   arg1 = (Dali::Quaternion *)jarg1;
10282   arg2 = (Dali::Quaternion *)jarg2;
10283   if (!arg2) {
10284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10285     return 0;
10286   }
10287   {
10288     try {
10289       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10290     } catch (std::out_of_range& e) {
10291       {
10292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10293       };
10294     } catch (std::exception& e) {
10295       {
10296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10297       };
10298     } catch (...) {
10299       {
10300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10301       };
10302     }
10303   }
10304   jresult = result;
10305   return jresult;
10306 }
10307
10308
10309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10310   unsigned int jresult ;
10311   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10312   Dali::Quaternion *arg2 = 0 ;
10313   bool result;
10314
10315   arg1 = (Dali::Quaternion *)jarg1;
10316   arg2 = (Dali::Quaternion *)jarg2;
10317   if (!arg2) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10319     return 0;
10320   }
10321   {
10322     try {
10323       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (...) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10335       };
10336     }
10337   }
10338   jresult = result;
10339   return jresult;
10340 }
10341
10342
10343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10344   float jresult ;
10345   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10346   float result;
10347
10348   arg1 = (Dali::Quaternion *)jarg1;
10349   {
10350     try {
10351       result = (float)((Dali::Quaternion const *)arg1)->Length();
10352     } catch (std::out_of_range& e) {
10353       {
10354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10355       };
10356     } catch (std::exception& e) {
10357       {
10358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10359       };
10360     } catch (...) {
10361       {
10362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10363       };
10364     }
10365   }
10366   jresult = result;
10367   return jresult;
10368 }
10369
10370
10371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10372   float jresult ;
10373   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10374   float result;
10375
10376   arg1 = (Dali::Quaternion *)jarg1;
10377   {
10378     try {
10379       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10380     } catch (std::out_of_range& e) {
10381       {
10382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10383       };
10384     } catch (std::exception& e) {
10385       {
10386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10387       };
10388     } catch (...) {
10389       {
10390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10391       };
10392     }
10393   }
10394   jresult = result;
10395   return jresult;
10396 }
10397
10398
10399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10400   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10401
10402   arg1 = (Dali::Quaternion *)jarg1;
10403   {
10404     try {
10405       (arg1)->Normalize();
10406     } catch (std::out_of_range& e) {
10407       {
10408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10409       };
10410     } catch (std::exception& e) {
10411       {
10412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10413       };
10414     } catch (...) {
10415       {
10416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10417       };
10418     }
10419   }
10420 }
10421
10422
10423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10424   void * jresult ;
10425   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10426   Dali::Quaternion result;
10427
10428   arg1 = (Dali::Quaternion *)jarg1;
10429   {
10430     try {
10431       result = ((Dali::Quaternion const *)arg1)->Normalized();
10432     } catch (std::out_of_range& e) {
10433       {
10434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10435       };
10436     } catch (std::exception& e) {
10437       {
10438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10439       };
10440     } catch (...) {
10441       {
10442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10443       };
10444     }
10445   }
10446   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10447   return jresult;
10448 }
10449
10450
10451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10452   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10453
10454   arg1 = (Dali::Quaternion *)jarg1;
10455   {
10456     try {
10457       (arg1)->Conjugate();
10458     } catch (std::out_of_range& e) {
10459       {
10460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10461       };
10462     } catch (std::exception& e) {
10463       {
10464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10465       };
10466     } catch (...) {
10467       {
10468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10469       };
10470     }
10471   }
10472 }
10473
10474
10475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10476   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10477
10478   arg1 = (Dali::Quaternion *)jarg1;
10479   {
10480     try {
10481       (arg1)->Invert();
10482     } catch (std::out_of_range& e) {
10483       {
10484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10485       };
10486     } catch (std::exception& e) {
10487       {
10488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10489       };
10490     } catch (...) {
10491       {
10492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10493       };
10494     }
10495   }
10496 }
10497
10498
10499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10500   void * jresult ;
10501   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10502   Dali::Quaternion result;
10503
10504   arg1 = (Dali::Quaternion *)jarg1;
10505   {
10506     try {
10507       result = ((Dali::Quaternion const *)arg1)->Log();
10508     } catch (std::out_of_range& e) {
10509       {
10510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10511       };
10512     } catch (std::exception& e) {
10513       {
10514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (...) {
10517       {
10518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10519       };
10520     }
10521   }
10522   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10523   return jresult;
10524 }
10525
10526
10527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10528   void * jresult ;
10529   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10530   Dali::Quaternion result;
10531
10532   arg1 = (Dali::Quaternion *)jarg1;
10533   {
10534     try {
10535       result = ((Dali::Quaternion const *)arg1)->Exp();
10536     } catch (std::out_of_range& e) {
10537       {
10538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10539       };
10540     } catch (std::exception& e) {
10541       {
10542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10543       };
10544     } catch (...) {
10545       {
10546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10547       };
10548     }
10549   }
10550   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10551   return jresult;
10552 }
10553
10554
10555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10556   float jresult ;
10557   Dali::Quaternion *arg1 = 0 ;
10558   Dali::Quaternion *arg2 = 0 ;
10559   float result;
10560
10561   arg1 = (Dali::Quaternion *)jarg1;
10562   if (!arg1) {
10563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10564     return 0;
10565   }
10566   arg2 = (Dali::Quaternion *)jarg2;
10567   if (!arg2) {
10568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10569     return 0;
10570   }
10571   {
10572     try {
10573       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10574     } catch (std::out_of_range& e) {
10575       {
10576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10577       };
10578     } catch (std::exception& e) {
10579       {
10580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10581       };
10582     } catch (...) {
10583       {
10584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10585       };
10586     }
10587   }
10588   jresult = result;
10589   return jresult;
10590 }
10591
10592
10593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10594   void * jresult ;
10595   Dali::Quaternion *arg1 = 0 ;
10596   Dali::Quaternion *arg2 = 0 ;
10597   float arg3 ;
10598   Dali::Quaternion result;
10599
10600   arg1 = (Dali::Quaternion *)jarg1;
10601   if (!arg1) {
10602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10603     return 0;
10604   }
10605   arg2 = (Dali::Quaternion *)jarg2;
10606   if (!arg2) {
10607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10608     return 0;
10609   }
10610   arg3 = (float)jarg3;
10611   {
10612     try {
10613       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10614     } catch (std::out_of_range& e) {
10615       {
10616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10617       };
10618     } catch (std::exception& e) {
10619       {
10620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10621       };
10622     } catch (...) {
10623       {
10624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10625       };
10626     }
10627   }
10628   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10629   return jresult;
10630 }
10631
10632
10633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10634   void * jresult ;
10635   Dali::Quaternion *arg1 = 0 ;
10636   Dali::Quaternion *arg2 = 0 ;
10637   float arg3 ;
10638   Dali::Quaternion result;
10639
10640   arg1 = (Dali::Quaternion *)jarg1;
10641   if (!arg1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10643     return 0;
10644   }
10645   arg2 = (Dali::Quaternion *)jarg2;
10646   if (!arg2) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10648     return 0;
10649   }
10650   arg3 = (float)jarg3;
10651   {
10652     try {
10653       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10654     } catch (std::out_of_range& e) {
10655       {
10656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10657       };
10658     } catch (std::exception& e) {
10659       {
10660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10661       };
10662     } catch (...) {
10663       {
10664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10665       };
10666     }
10667   }
10668   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10669   return jresult;
10670 }
10671
10672
10673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10674   void * jresult ;
10675   Dali::Quaternion *arg1 = 0 ;
10676   Dali::Quaternion *arg2 = 0 ;
10677   float arg3 ;
10678   Dali::Quaternion result;
10679
10680   arg1 = (Dali::Quaternion *)jarg1;
10681   if (!arg1) {
10682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10683     return 0;
10684   }
10685   arg2 = (Dali::Quaternion *)jarg2;
10686   if (!arg2) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10688     return 0;
10689   }
10690   arg3 = (float)jarg3;
10691   {
10692     try {
10693       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10694     } catch (std::out_of_range& e) {
10695       {
10696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10697       };
10698     } catch (std::exception& e) {
10699       {
10700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10701       };
10702     } catch (...) {
10703       {
10704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10705       };
10706     }
10707   }
10708   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10709   return jresult;
10710 }
10711
10712
10713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10714   void * jresult ;
10715   Dali::Quaternion *arg1 = 0 ;
10716   Dali::Quaternion *arg2 = 0 ;
10717   Dali::Quaternion *arg3 = 0 ;
10718   Dali::Quaternion *arg4 = 0 ;
10719   float arg5 ;
10720   Dali::Quaternion result;
10721
10722   arg1 = (Dali::Quaternion *)jarg1;
10723   if (!arg1) {
10724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10725     return 0;
10726   }
10727   arg2 = (Dali::Quaternion *)jarg2;
10728   if (!arg2) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10730     return 0;
10731   }
10732   arg3 = (Dali::Quaternion *)jarg3;
10733   if (!arg3) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10735     return 0;
10736   }
10737   arg4 = (Dali::Quaternion *)jarg4;
10738   if (!arg4) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10740     return 0;
10741   }
10742   arg5 = (float)jarg5;
10743   {
10744     try {
10745       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10746     } catch (std::out_of_range& e) {
10747       {
10748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10749       };
10750     } catch (std::exception& e) {
10751       {
10752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10753       };
10754     } catch (...) {
10755       {
10756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10757       };
10758     }
10759   }
10760   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10761   return jresult;
10762 }
10763
10764
10765 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10766   float jresult ;
10767   Dali::Quaternion *arg1 = 0 ;
10768   Dali::Quaternion *arg2 = 0 ;
10769   float result;
10770
10771   arg1 = (Dali::Quaternion *)jarg1;
10772   if (!arg1) {
10773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10774     return 0;
10775   }
10776   arg2 = (Dali::Quaternion *)jarg2;
10777   if (!arg2) {
10778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10779     return 0;
10780   }
10781   {
10782     try {
10783       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10784     } catch (std::out_of_range& e) {
10785       {
10786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10787       };
10788     } catch (std::exception& e) {
10789       {
10790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (...) {
10793       {
10794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10795       };
10796     }
10797   }
10798   jresult = result;
10799   return jresult;
10800 }
10801
10802
10803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10804   void * jresult ;
10805   Dali::Matrix *result = 0 ;
10806
10807   {
10808     try {
10809       result = (Dali::Matrix *)new Dali::Matrix();
10810     } catch (std::out_of_range& e) {
10811       {
10812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10813       };
10814     } catch (std::exception& e) {
10815       {
10816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10817       };
10818     } catch (...) {
10819       {
10820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10821       };
10822     }
10823   }
10824   jresult = (void *)result;
10825   return jresult;
10826 }
10827
10828
10829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10830   void * jresult ;
10831   bool arg1 ;
10832   Dali::Matrix *result = 0 ;
10833
10834   arg1 = jarg1 ? true : false;
10835   {
10836     try {
10837       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10838     } catch (std::out_of_range& e) {
10839       {
10840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10841       };
10842     } catch (std::exception& e) {
10843       {
10844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10845       };
10846     } catch (...) {
10847       {
10848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10849       };
10850     }
10851   }
10852   jresult = (void *)result;
10853   return jresult;
10854 }
10855
10856
10857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10858   void * jresult ;
10859   float *arg1 = (float *) 0 ;
10860   Dali::Matrix *result = 0 ;
10861
10862   arg1 = jarg1;
10863   {
10864     try {
10865       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10866     } catch (std::out_of_range& e) {
10867       {
10868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (std::exception& e) {
10871       {
10872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (...) {
10875       {
10876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10877       };
10878     }
10879   }
10880   jresult = (void *)result;
10881
10882
10883   return jresult;
10884 }
10885
10886
10887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10888   void * jresult ;
10889   Dali::Quaternion *arg1 = 0 ;
10890   Dali::Matrix *result = 0 ;
10891
10892   arg1 = (Dali::Quaternion *)jarg1;
10893   if (!arg1) {
10894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10895     return 0;
10896   }
10897   {
10898     try {
10899       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10900     } catch (std::out_of_range& e) {
10901       {
10902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10903       };
10904     } catch (std::exception& e) {
10905       {
10906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10907       };
10908     } catch (...) {
10909       {
10910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10911       };
10912     }
10913   }
10914   jresult = (void *)result;
10915   return jresult;
10916 }
10917
10918
10919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10920   void * jresult ;
10921   Dali::Matrix *arg1 = 0 ;
10922   Dali::Matrix *result = 0 ;
10923
10924   arg1 = (Dali::Matrix *)jarg1;
10925   if (!arg1) {
10926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10927     return 0;
10928   }
10929   {
10930     try {
10931       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10932     } catch (std::out_of_range& e) {
10933       {
10934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10935       };
10936     } catch (std::exception& e) {
10937       {
10938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10939       };
10940     } catch (...) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10943       };
10944     }
10945   }
10946   jresult = (void *)result;
10947   return jresult;
10948 }
10949
10950
10951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10952   void * jresult ;
10953   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10954   Dali::Matrix *arg2 = 0 ;
10955   Dali::Matrix *result = 0 ;
10956
10957   arg1 = (Dali::Matrix *)jarg1;
10958   arg2 = (Dali::Matrix *)jarg2;
10959   if (!arg2) {
10960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10961     return 0;
10962   }
10963   {
10964     try {
10965       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10966     } catch (std::out_of_range& e) {
10967       {
10968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10969       };
10970     } catch (std::exception& e) {
10971       {
10972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10973       };
10974     } catch (...) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10977       };
10978     }
10979   }
10980   jresult = (void *)result;
10981   return jresult;
10982 }
10983
10984
10985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
10986   void * jresult ;
10987   Dali::Matrix *result = 0 ;
10988
10989   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
10990   jresult = (void *)result;
10991   return jresult;
10992 }
10993
10994
10995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
10996   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10997
10998   arg1 = (Dali::Matrix *)jarg1;
10999   {
11000     try {
11001       (arg1)->SetIdentity();
11002     } catch (std::out_of_range& e) {
11003       {
11004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11005       };
11006     } catch (std::exception& e) {
11007       {
11008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11009       };
11010     } catch (...) {
11011       {
11012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11013       };
11014     }
11015   }
11016 }
11017
11018
11019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11020   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11021   Dali::Vector3 *arg2 = 0 ;
11022
11023   arg1 = (Dali::Matrix *)jarg1;
11024   arg2 = (Dali::Vector3 *)jarg2;
11025   if (!arg2) {
11026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11027     return ;
11028   }
11029   {
11030     try {
11031       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11032     } catch (std::out_of_range& e) {
11033       {
11034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11035       };
11036     } catch (std::exception& e) {
11037       {
11038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11039       };
11040     } catch (...) {
11041       {
11042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11043       };
11044     }
11045   }
11046 }
11047
11048
11049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11050   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11051   Dali::Matrix *arg2 = 0 ;
11052
11053   arg1 = (Dali::Matrix *)jarg1;
11054   arg2 = (Dali::Matrix *)jarg2;
11055   if (!arg2) {
11056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11057     return ;
11058   }
11059   {
11060     try {
11061       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11062     } catch (std::out_of_range& e) {
11063       {
11064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11065       };
11066     } catch (std::exception& e) {
11067       {
11068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11069       };
11070     } catch (...) {
11071       {
11072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11073       };
11074     }
11075   }
11076 }
11077
11078
11079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11080   unsigned int jresult ;
11081   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11082   bool result;
11083
11084   arg1 = (Dali::Matrix *)jarg1;
11085   {
11086     try {
11087       result = (bool)(arg1)->Invert();
11088     } catch (std::out_of_range& e) {
11089       {
11090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11091       };
11092     } catch (std::exception& e) {
11093       {
11094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11095       };
11096     } catch (...) {
11097       {
11098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11099       };
11100     }
11101   }
11102   jresult = result;
11103   return jresult;
11104 }
11105
11106
11107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11108   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11109
11110   arg1 = (Dali::Matrix *)jarg1;
11111   {
11112     try {
11113       (arg1)->Transpose();
11114     } catch (std::out_of_range& e) {
11115       {
11116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11117       };
11118     } catch (std::exception& e) {
11119       {
11120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11121       };
11122     } catch (...) {
11123       {
11124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11125       };
11126     }
11127   }
11128 }
11129
11130
11131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11132   void * jresult ;
11133   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11134   Dali::Vector3 result;
11135
11136   arg1 = (Dali::Matrix *)jarg1;
11137   {
11138     try {
11139       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11147       };
11148     } catch (...) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11151       };
11152     }
11153   }
11154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11160   void * jresult ;
11161   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11162   Dali::Vector3 result;
11163
11164   arg1 = (Dali::Matrix *)jarg1;
11165   {
11166     try {
11167       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11168     } catch (std::out_of_range& e) {
11169       {
11170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11171       };
11172     } catch (std::exception& e) {
11173       {
11174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11175       };
11176     } catch (...) {
11177       {
11178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11179       };
11180     }
11181   }
11182   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11183   return jresult;
11184 }
11185
11186
11187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11188   void * jresult ;
11189   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11190   Dali::Vector3 result;
11191
11192   arg1 = (Dali::Matrix *)jarg1;
11193   {
11194     try {
11195       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11196     } catch (std::out_of_range& e) {
11197       {
11198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11199       };
11200     } catch (std::exception& e) {
11201       {
11202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11203       };
11204     } catch (...) {
11205       {
11206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11207       };
11208     }
11209   }
11210   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11211   return jresult;
11212 }
11213
11214
11215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11216   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11217   Dali::Vector3 *arg2 = 0 ;
11218
11219   arg1 = (Dali::Matrix *)jarg1;
11220   arg2 = (Dali::Vector3 *)jarg2;
11221   if (!arg2) {
11222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11223     return ;
11224   }
11225   {
11226     try {
11227       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11228     } catch (std::out_of_range& e) {
11229       {
11230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11231       };
11232     } catch (std::exception& e) {
11233       {
11234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11235       };
11236     } catch (...) {
11237       {
11238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11239       };
11240     }
11241   }
11242 }
11243
11244
11245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11246   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11247   Dali::Vector3 *arg2 = 0 ;
11248
11249   arg1 = (Dali::Matrix *)jarg1;
11250   arg2 = (Dali::Vector3 *)jarg2;
11251   if (!arg2) {
11252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11253     return ;
11254   }
11255   {
11256     try {
11257       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11258     } catch (std::out_of_range& e) {
11259       {
11260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11261       };
11262     } catch (std::exception& e) {
11263       {
11264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11265       };
11266     } catch (...) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11269       };
11270     }
11271   }
11272 }
11273
11274
11275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11276   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11277   Dali::Vector3 *arg2 = 0 ;
11278
11279   arg1 = (Dali::Matrix *)jarg1;
11280   arg2 = (Dali::Vector3 *)jarg2;
11281   if (!arg2) {
11282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11283     return ;
11284   }
11285   {
11286     try {
11287       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11288     } catch (std::out_of_range& e) {
11289       {
11290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11291       };
11292     } catch (std::exception& e) {
11293       {
11294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11295       };
11296     } catch (...) {
11297       {
11298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11299       };
11300     }
11301   }
11302 }
11303
11304
11305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11306   void * jresult ;
11307   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11308   Dali::Vector4 *result = 0 ;
11309
11310   arg1 = (Dali::Matrix *)jarg1;
11311   {
11312     try {
11313       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11314     } catch (std::out_of_range& e) {
11315       {
11316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11317       };
11318     } catch (std::exception& e) {
11319       {
11320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11321       };
11322     } catch (...) {
11323       {
11324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11325       };
11326     }
11327   }
11328   jresult = (void *)result;
11329   return jresult;
11330 }
11331
11332
11333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11334   void * jresult ;
11335   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11336   Dali::Vector3 *result = 0 ;
11337
11338   arg1 = (Dali::Matrix *)jarg1;
11339   {
11340     try {
11341       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11342     } catch (std::out_of_range& e) {
11343       {
11344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11345       };
11346     } catch (std::exception& e) {
11347       {
11348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11349       };
11350     } catch (...) {
11351       {
11352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11353       };
11354     }
11355   }
11356   jresult = (void *)result;
11357   return jresult;
11358 }
11359
11360
11361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11362   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11363   Dali::Vector4 *arg2 = 0 ;
11364
11365   arg1 = (Dali::Matrix *)jarg1;
11366   arg2 = (Dali::Vector4 *)jarg2;
11367   if (!arg2) {
11368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11369     return ;
11370   }
11371   {
11372     try {
11373       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11374     } catch (std::out_of_range& e) {
11375       {
11376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11377       };
11378     } catch (std::exception& e) {
11379       {
11380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11381       };
11382     } catch (...) {
11383       {
11384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11385       };
11386     }
11387   }
11388 }
11389
11390
11391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11392   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11393   Dali::Vector3 *arg2 = 0 ;
11394
11395   arg1 = (Dali::Matrix *)jarg1;
11396   arg2 = (Dali::Vector3 *)jarg2;
11397   if (!arg2) {
11398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11399     return ;
11400   }
11401   {
11402     try {
11403       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11404     } catch (std::out_of_range& e) {
11405       {
11406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11407       };
11408     } catch (std::exception& e) {
11409       {
11410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11411       };
11412     } catch (...) {
11413       {
11414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11415       };
11416     }
11417   }
11418 }
11419
11420
11421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11422   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11423
11424   arg1 = (Dali::Matrix *)jarg1;
11425   {
11426     try {
11427       (arg1)->OrthoNormalize();
11428     } catch (std::out_of_range& e) {
11429       {
11430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11431       };
11432     } catch (std::exception& e) {
11433       {
11434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11435       };
11436     } catch (...) {
11437       {
11438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11439       };
11440     }
11441   }
11442 }
11443
11444
11445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11446   void * jresult ;
11447   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11448   float *result = 0 ;
11449
11450   arg1 = (Dali::Matrix *)jarg1;
11451   {
11452     try {
11453       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11454     } catch (std::out_of_range& e) {
11455       {
11456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11457       };
11458     } catch (std::exception& e) {
11459       {
11460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11461       };
11462     } catch (...) {
11463       {
11464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11465       };
11466     }
11467   }
11468   jresult = (void *)result;
11469   return jresult;
11470 }
11471
11472
11473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11474   Dali::Matrix *arg1 = 0 ;
11475   Dali::Matrix *arg2 = 0 ;
11476   Dali::Matrix *arg3 = 0 ;
11477
11478   arg1 = (Dali::Matrix *)jarg1;
11479   if (!arg1) {
11480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11481     return ;
11482   }
11483   arg2 = (Dali::Matrix *)jarg2;
11484   if (!arg2) {
11485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11486     return ;
11487   }
11488   arg3 = (Dali::Matrix *)jarg3;
11489   if (!arg3) {
11490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11491     return ;
11492   }
11493   {
11494     try {
11495       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11496     } catch (std::out_of_range& e) {
11497       {
11498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11499       };
11500     } catch (std::exception& e) {
11501       {
11502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11503       };
11504     } catch (...) {
11505       {
11506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11507       };
11508     }
11509   }
11510 }
11511
11512
11513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11514   Dali::Matrix *arg1 = 0 ;
11515   Dali::Matrix *arg2 = 0 ;
11516   Dali::Quaternion *arg3 = 0 ;
11517
11518   arg1 = (Dali::Matrix *)jarg1;
11519   if (!arg1) {
11520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11521     return ;
11522   }
11523   arg2 = (Dali::Matrix *)jarg2;
11524   if (!arg2) {
11525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11526     return ;
11527   }
11528   arg3 = (Dali::Quaternion *)jarg3;
11529   if (!arg3) {
11530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11531     return ;
11532   }
11533   {
11534     try {
11535       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11536     } catch (std::out_of_range& e) {
11537       {
11538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11539       };
11540     } catch (std::exception& e) {
11541       {
11542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11543       };
11544     } catch (...) {
11545       {
11546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11547       };
11548     }
11549   }
11550 }
11551
11552
11553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11554   void * jresult ;
11555   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11556   Dali::Vector4 *arg2 = 0 ;
11557   Dali::Vector4 result;
11558
11559   arg1 = (Dali::Matrix *)jarg1;
11560   arg2 = (Dali::Vector4 *)jarg2;
11561   if (!arg2) {
11562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11563     return 0;
11564   }
11565   {
11566     try {
11567       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11568     } catch (std::out_of_range& e) {
11569       {
11570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11571       };
11572     } catch (std::exception& e) {
11573       {
11574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11575       };
11576     } catch (...) {
11577       {
11578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11579       };
11580     }
11581   }
11582   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11583   return jresult;
11584 }
11585
11586
11587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11588   unsigned int jresult ;
11589   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11590   Dali::Matrix *arg2 = 0 ;
11591   bool result;
11592
11593   arg1 = (Dali::Matrix *)jarg1;
11594   arg2 = (Dali::Matrix *)jarg2;
11595   if (!arg2) {
11596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11597     return 0;
11598   }
11599   {
11600     try {
11601       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11602     } catch (std::out_of_range& e) {
11603       {
11604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11605       };
11606     } catch (std::exception& e) {
11607       {
11608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11609       };
11610     } catch (...) {
11611       {
11612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11613       };
11614     }
11615   }
11616   jresult = result;
11617   return jresult;
11618 }
11619
11620
11621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11622   unsigned int jresult ;
11623   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11624   Dali::Matrix *arg2 = 0 ;
11625   bool result;
11626
11627   arg1 = (Dali::Matrix *)jarg1;
11628   arg2 = (Dali::Matrix *)jarg2;
11629   if (!arg2) {
11630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11631     return 0;
11632   }
11633   {
11634     try {
11635       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11636     } catch (std::out_of_range& e) {
11637       {
11638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11639       };
11640     } catch (std::exception& e) {
11641       {
11642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11643       };
11644     } catch (...) {
11645       {
11646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11647       };
11648     }
11649   }
11650   jresult = result;
11651   return jresult;
11652 }
11653
11654
11655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11656   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11657   Dali::Vector3 *arg2 = 0 ;
11658   Dali::Quaternion *arg3 = 0 ;
11659   Dali::Vector3 *arg4 = 0 ;
11660
11661   arg1 = (Dali::Matrix *)jarg1;
11662   arg2 = (Dali::Vector3 *)jarg2;
11663   if (!arg2) {
11664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11665     return ;
11666   }
11667   arg3 = (Dali::Quaternion *)jarg3;
11668   if (!arg3) {
11669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11670     return ;
11671   }
11672   arg4 = (Dali::Vector3 *)jarg4;
11673   if (!arg4) {
11674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11675     return ;
11676   }
11677   {
11678     try {
11679       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11680     } catch (std::out_of_range& e) {
11681       {
11682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11683       };
11684     } catch (std::exception& e) {
11685       {
11686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11687       };
11688     } catch (...) {
11689       {
11690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11691       };
11692     }
11693   }
11694 }
11695
11696
11697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11698   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11699   Dali::Vector3 *arg2 = 0 ;
11700   Dali::Quaternion *arg3 = 0 ;
11701   Dali::Vector3 *arg4 = 0 ;
11702
11703   arg1 = (Dali::Matrix *)jarg1;
11704   arg2 = (Dali::Vector3 *)jarg2;
11705   if (!arg2) {
11706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11707     return ;
11708   }
11709   arg3 = (Dali::Quaternion *)jarg3;
11710   if (!arg3) {
11711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11712     return ;
11713   }
11714   arg4 = (Dali::Vector3 *)jarg4;
11715   if (!arg4) {
11716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11717     return ;
11718   }
11719   {
11720     try {
11721       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11722     } catch (std::out_of_range& e) {
11723       {
11724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11725       };
11726     } catch (std::exception& e) {
11727       {
11728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11729       };
11730     } catch (...) {
11731       {
11732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11733       };
11734     }
11735   }
11736 }
11737
11738
11739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11740   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11741   Dali::Vector3 *arg2 = 0 ;
11742   Dali::Vector3 *arg3 = 0 ;
11743   Dali::Vector3 *arg4 = 0 ;
11744   Dali::Vector3 *arg5 = 0 ;
11745
11746   arg1 = (Dali::Matrix *)jarg1;
11747   arg2 = (Dali::Vector3 *)jarg2;
11748   if (!arg2) {
11749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11750     return ;
11751   }
11752   arg3 = (Dali::Vector3 *)jarg3;
11753   if (!arg3) {
11754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11755     return ;
11756   }
11757   arg4 = (Dali::Vector3 *)jarg4;
11758   if (!arg4) {
11759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11760     return ;
11761   }
11762   arg5 = (Dali::Vector3 *)jarg5;
11763   if (!arg5) {
11764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11765     return ;
11766   }
11767   {
11768     try {
11769       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11770     } catch (std::out_of_range& e) {
11771       {
11772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11773       };
11774     } catch (std::exception& e) {
11775       {
11776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11777       };
11778     } catch (...) {
11779       {
11780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11781       };
11782     }
11783   }
11784 }
11785
11786
11787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11788   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11789   Dali::Vector3 *arg2 = 0 ;
11790   Dali::Quaternion *arg3 = 0 ;
11791   Dali::Vector3 *arg4 = 0 ;
11792
11793   arg1 = (Dali::Matrix *)jarg1;
11794   arg2 = (Dali::Vector3 *)jarg2;
11795   if (!arg2) {
11796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11797     return ;
11798   }
11799   arg3 = (Dali::Quaternion *)jarg3;
11800   if (!arg3) {
11801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11802     return ;
11803   }
11804   arg4 = (Dali::Vector3 *)jarg4;
11805   if (!arg4) {
11806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11807     return ;
11808   }
11809   {
11810     try {
11811       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11812     } catch (std::out_of_range& e) {
11813       {
11814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11815       };
11816     } catch (std::exception& e) {
11817       {
11818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (...) {
11821       {
11822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11823       };
11824     }
11825   }
11826 }
11827
11828
11829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11830   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11831
11832   arg1 = (Dali::Matrix *)jarg1;
11833   {
11834     try {
11835       delete arg1;
11836     } catch (std::out_of_range& e) {
11837       {
11838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11839       };
11840     } catch (std::exception& e) {
11841       {
11842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11843       };
11844     } catch (...) {
11845       {
11846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11847       };
11848     }
11849   }
11850 }
11851
11852
11853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11854   void * jresult ;
11855   Dali::Matrix3 *result = 0 ;
11856
11857   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11858   jresult = (void *)result;
11859   return jresult;
11860 }
11861
11862
11863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11864   void * jresult ;
11865   Dali::Matrix3 *result = 0 ;
11866
11867   {
11868     try {
11869       result = (Dali::Matrix3 *)new Dali::Matrix3();
11870     } catch (std::out_of_range& e) {
11871       {
11872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11873       };
11874     } catch (std::exception& e) {
11875       {
11876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (...) {
11879       {
11880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11881       };
11882     }
11883   }
11884   jresult = (void *)result;
11885   return jresult;
11886 }
11887
11888
11889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11890   void * jresult ;
11891   Dali::Matrix3 *arg1 = 0 ;
11892   Dali::Matrix3 *result = 0 ;
11893
11894   arg1 = (Dali::Matrix3 *)jarg1;
11895   if (!arg1) {
11896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11897     return 0;
11898   }
11899   {
11900     try {
11901       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11902     } catch (std::out_of_range& e) {
11903       {
11904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11905       };
11906     } catch (std::exception& e) {
11907       {
11908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11909       };
11910     } catch (...) {
11911       {
11912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11913       };
11914     }
11915   }
11916   jresult = (void *)result;
11917   return jresult;
11918 }
11919
11920
11921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11922   void * jresult ;
11923   Dali::Matrix *arg1 = 0 ;
11924   Dali::Matrix3 *result = 0 ;
11925
11926   arg1 = (Dali::Matrix *)jarg1;
11927   if (!arg1) {
11928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11929     return 0;
11930   }
11931   {
11932     try {
11933       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11934     } catch (std::out_of_range& e) {
11935       {
11936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11937       };
11938     } catch (std::exception& e) {
11939       {
11940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11941       };
11942     } catch (...) {
11943       {
11944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11945       };
11946     }
11947   }
11948   jresult = (void *)result;
11949   return jresult;
11950 }
11951
11952
11953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
11954   void * jresult ;
11955   float arg1 ;
11956   float arg2 ;
11957   float arg3 ;
11958   float arg4 ;
11959   float arg5 ;
11960   float arg6 ;
11961   float arg7 ;
11962   float arg8 ;
11963   float arg9 ;
11964   Dali::Matrix3 *result = 0 ;
11965
11966   arg1 = (float)jarg1;
11967   arg2 = (float)jarg2;
11968   arg3 = (float)jarg3;
11969   arg4 = (float)jarg4;
11970   arg5 = (float)jarg5;
11971   arg6 = (float)jarg6;
11972   arg7 = (float)jarg7;
11973   arg8 = (float)jarg8;
11974   arg9 = (float)jarg9;
11975   {
11976     try {
11977       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11978     } catch (std::out_of_range& e) {
11979       {
11980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11981       };
11982     } catch (std::exception& e) {
11983       {
11984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11985       };
11986     } catch (...) {
11987       {
11988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11989       };
11990     }
11991   }
11992   jresult = (void *)result;
11993   return jresult;
11994 }
11995
11996
11997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
11998   void * jresult ;
11999   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12000   Dali::Matrix3 *arg2 = 0 ;
12001   Dali::Matrix3 *result = 0 ;
12002
12003   arg1 = (Dali::Matrix3 *)jarg1;
12004   arg2 = (Dali::Matrix3 *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12007     return 0;
12008   }
12009   {
12010     try {
12011       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12012     } catch (std::out_of_range& e) {
12013       {
12014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (std::exception& e) {
12017       {
12018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (...) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12023       };
12024     }
12025   }
12026   jresult = (void *)result;
12027   return jresult;
12028 }
12029
12030
12031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12032   void * jresult ;
12033   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12034   Dali::Matrix *arg2 = 0 ;
12035   Dali::Matrix3 *result = 0 ;
12036
12037   arg1 = (Dali::Matrix3 *)jarg1;
12038   arg2 = (Dali::Matrix *)jarg2;
12039   if (!arg2) {
12040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12041     return 0;
12042   }
12043   {
12044     try {
12045       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12046     } catch (std::out_of_range& e) {
12047       {
12048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12049       };
12050     } catch (std::exception& e) {
12051       {
12052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12053       };
12054     } catch (...) {
12055       {
12056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12057       };
12058     }
12059   }
12060   jresult = (void *)result;
12061   return jresult;
12062 }
12063
12064
12065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12066   unsigned int jresult ;
12067   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12068   Dali::Matrix3 *arg2 = 0 ;
12069   bool result;
12070
12071   arg1 = (Dali::Matrix3 *)jarg1;
12072   arg2 = (Dali::Matrix3 *)jarg2;
12073   if (!arg2) {
12074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12075     return 0;
12076   }
12077   {
12078     try {
12079       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12080     } catch (std::out_of_range& e) {
12081       {
12082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (std::exception& e) {
12085       {
12086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12087       };
12088     } catch (...) {
12089       {
12090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12091       };
12092     }
12093   }
12094   jresult = result;
12095   return jresult;
12096 }
12097
12098
12099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12100   unsigned int jresult ;
12101   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12102   Dali::Matrix3 *arg2 = 0 ;
12103   bool result;
12104
12105   arg1 = (Dali::Matrix3 *)jarg1;
12106   arg2 = (Dali::Matrix3 *)jarg2;
12107   if (!arg2) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12109     return 0;
12110   }
12111   {
12112     try {
12113       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12114     } catch (std::out_of_range& e) {
12115       {
12116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (std::exception& e) {
12119       {
12120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (...) {
12123       {
12124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12125       };
12126     }
12127   }
12128   jresult = result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12134   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12135
12136   arg1 = (Dali::Matrix3 *)jarg1;
12137   {
12138     try {
12139       delete arg1;
12140     } catch (std::out_of_range& e) {
12141       {
12142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12143       };
12144     } catch (std::exception& e) {
12145       {
12146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12147       };
12148     } catch (...) {
12149       {
12150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12151       };
12152     }
12153   }
12154 }
12155
12156
12157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12158   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12159
12160   arg1 = (Dali::Matrix3 *)jarg1;
12161   {
12162     try {
12163       (arg1)->SetIdentity();
12164     } catch (std::out_of_range& e) {
12165       {
12166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12167       };
12168     } catch (std::exception& e) {
12169       {
12170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12171       };
12172     } catch (...) {
12173       {
12174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12175       };
12176     }
12177   }
12178 }
12179
12180
12181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12182   void * jresult ;
12183   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12184   float *result = 0 ;
12185
12186   arg1 = (Dali::Matrix3 *)jarg1;
12187   {
12188     try {
12189       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12190     } catch (std::out_of_range& e) {
12191       {
12192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12193       };
12194     } catch (std::exception& e) {
12195       {
12196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12197       };
12198     } catch (...) {
12199       {
12200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12201       };
12202     }
12203   }
12204   jresult = (void *)result;
12205   return jresult;
12206 }
12207
12208
12209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12210   unsigned int jresult ;
12211   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12212   bool result;
12213
12214   arg1 = (Dali::Matrix3 *)jarg1;
12215   {
12216     try {
12217       result = (bool)(arg1)->Invert();
12218     } catch (std::out_of_range& e) {
12219       {
12220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (std::exception& e) {
12223       {
12224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (...) {
12227       {
12228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12229       };
12230     }
12231   }
12232   jresult = result;
12233   return jresult;
12234 }
12235
12236
12237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12238   unsigned int jresult ;
12239   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12240   bool result;
12241
12242   arg1 = (Dali::Matrix3 *)jarg1;
12243   {
12244     try {
12245       result = (bool)(arg1)->Transpose();
12246     } catch (std::out_of_range& e) {
12247       {
12248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12249       };
12250     } catch (std::exception& e) {
12251       {
12252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12257       };
12258     }
12259   }
12260   jresult = result;
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12266   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12267   float arg2 ;
12268
12269   arg1 = (Dali::Matrix3 *)jarg1;
12270   arg2 = (float)jarg2;
12271   {
12272     try {
12273       (arg1)->Scale(arg2);
12274     } catch (std::out_of_range& e) {
12275       {
12276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12277       };
12278     } catch (std::exception& e) {
12279       {
12280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12281       };
12282     } catch (...) {
12283       {
12284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12285       };
12286     }
12287   }
12288 }
12289
12290
12291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12292   float jresult ;
12293   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12294   float result;
12295
12296   arg1 = (Dali::Matrix3 *)jarg1;
12297   {
12298     try {
12299       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12300     } catch (std::out_of_range& e) {
12301       {
12302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12303       };
12304     } catch (std::exception& e) {
12305       {
12306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12307       };
12308     } catch (...) {
12309       {
12310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12311       };
12312     }
12313   }
12314   jresult = result;
12315   return jresult;
12316 }
12317
12318
12319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12320   unsigned int jresult ;
12321   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12322   bool result;
12323
12324   arg1 = (Dali::Matrix3 *)jarg1;
12325   {
12326     try {
12327       result = (bool)(arg1)->ScaledInverseTranspose();
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (...) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12339       };
12340     }
12341   }
12342   jresult = result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12348   Dali::Matrix3 *arg1 = 0 ;
12349   Dali::Matrix3 *arg2 = 0 ;
12350   Dali::Matrix3 *arg3 = 0 ;
12351
12352   arg1 = (Dali::Matrix3 *)jarg1;
12353   if (!arg1) {
12354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12355     return ;
12356   }
12357   arg2 = (Dali::Matrix3 *)jarg2;
12358   if (!arg2) {
12359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12360     return ;
12361   }
12362   arg3 = (Dali::Matrix3 *)jarg3;
12363   if (!arg3) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12365     return ;
12366   }
12367   {
12368     try {
12369       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12377       };
12378     } catch (...) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12381       };
12382     }
12383   }
12384 }
12385
12386
12387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12388   float jresult ;
12389   float arg1 ;
12390   float arg2 ;
12391   float result;
12392
12393   arg1 = (float)jarg1;
12394   arg2 = (float)jarg2;
12395   {
12396     try {
12397       result = (float)Dali::Random::Range(arg1,arg2);
12398     } catch (std::out_of_range& e) {
12399       {
12400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12401       };
12402     } catch (std::exception& e) {
12403       {
12404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12405       };
12406     } catch (...) {
12407       {
12408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12409       };
12410     }
12411   }
12412   jresult = result;
12413   return jresult;
12414 }
12415
12416
12417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12418   void * jresult ;
12419   Dali::Vector4 result;
12420
12421   {
12422     try {
12423       result = Dali::Random::Axis();
12424     } catch (std::out_of_range& e) {
12425       {
12426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12427       };
12428     } catch (std::exception& e) {
12429       {
12430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12431       };
12432     } catch (...) {
12433       {
12434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12435       };
12436     }
12437   }
12438   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12439   return jresult;
12440 }
12441
12442
12443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12444   void * jresult ;
12445   Dali::AngleAxis *result = 0 ;
12446
12447   {
12448     try {
12449       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12450     } catch (std::out_of_range& e) {
12451       {
12452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12453       };
12454     } catch (std::exception& e) {
12455       {
12456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12461       };
12462     }
12463   }
12464   jresult = (void *)result;
12465   return jresult;
12466 }
12467
12468
12469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12470   void * jresult ;
12471   Dali::Radian arg1 ;
12472   Dali::Vector3 *arg2 = 0 ;
12473   Dali::Radian *argp1 ;
12474   Dali::AngleAxis *result = 0 ;
12475
12476   argp1 = (Dali::Radian *)jarg1;
12477   if (!argp1) {
12478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12479     return 0;
12480   }
12481   arg1 = *argp1;
12482   arg2 = (Dali::Vector3 *)jarg2;
12483   if (!arg2) {
12484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12485     return 0;
12486   }
12487   {
12488     try {
12489       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12490     } catch (std::out_of_range& e) {
12491       {
12492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12493       };
12494     } catch (std::exception& e) {
12495       {
12496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12497       };
12498     } catch (...) {
12499       {
12500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12501       };
12502     }
12503   }
12504   jresult = (void *)result;
12505   return jresult;
12506 }
12507
12508
12509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12510   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12511   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12512
12513   arg1 = (Dali::AngleAxis *)jarg1;
12514   arg2 = (Dali::Radian *)jarg2;
12515   if (arg1) (arg1)->angle = *arg2;
12516 }
12517
12518
12519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12520   void * jresult ;
12521   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12522   Dali::Radian *result = 0 ;
12523
12524   arg1 = (Dali::AngleAxis *)jarg1;
12525   result = (Dali::Radian *)& ((arg1)->angle);
12526   jresult = (void *)result;
12527   return jresult;
12528 }
12529
12530
12531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12532   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12533   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12534
12535   arg1 = (Dali::AngleAxis *)jarg1;
12536   arg2 = (Dali::Vector3 *)jarg2;
12537   if (arg1) (arg1)->axis = *arg2;
12538 }
12539
12540
12541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12542   void * jresult ;
12543   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12544   Dali::Vector3 *result = 0 ;
12545
12546   arg1 = (Dali::AngleAxis *)jarg1;
12547   result = (Dali::Vector3 *)& ((arg1)->axis);
12548   jresult = (void *)result;
12549   return jresult;
12550 }
12551
12552
12553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12554   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12555
12556   arg1 = (Dali::AngleAxis *)jarg1;
12557   {
12558     try {
12559       delete arg1;
12560     } catch (std::out_of_range& e) {
12561       {
12562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12563       };
12564     } catch (std::exception& e) {
12565       {
12566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12567       };
12568     } catch (...) {
12569       {
12570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12571       };
12572     }
12573   }
12574 }
12575
12576
12577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12578   unsigned int jresult ;
12579   Dali::AngleAxis *arg1 = 0 ;
12580   Dali::AngleAxis *arg2 = 0 ;
12581   bool result;
12582
12583   arg1 = (Dali::AngleAxis *)jarg1;
12584   if (!arg1) {
12585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12586     return 0;
12587   }
12588   arg2 = (Dali::AngleAxis *)jarg2;
12589   if (!arg2) {
12590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12591     return 0;
12592   }
12593   {
12594     try {
12595       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12596     } catch (std::out_of_range& e) {
12597       {
12598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12599       };
12600     } catch (std::exception& e) {
12601       {
12602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12603       };
12604     } catch (...) {
12605       {
12606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12607       };
12608     }
12609   }
12610   jresult = result;
12611   return jresult;
12612 }
12613
12614
12615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12616   unsigned int jresult ;
12617   unsigned int arg1 ;
12618   unsigned int result;
12619
12620   arg1 = (unsigned int)jarg1;
12621   {
12622     try {
12623       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12624     } catch (std::out_of_range& e) {
12625       {
12626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12627       };
12628     } catch (std::exception& e) {
12629       {
12630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12631       };
12632     } catch (...) {
12633       {
12634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12635       };
12636     }
12637   }
12638   jresult = result;
12639   return jresult;
12640 }
12641
12642
12643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12644   unsigned int jresult ;
12645   unsigned int arg1 ;
12646   bool result;
12647
12648   arg1 = (unsigned int)jarg1;
12649   {
12650     try {
12651       result = (bool)Dali::IsPowerOfTwo(arg1);
12652     } catch (std::out_of_range& e) {
12653       {
12654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12655       };
12656     } catch (std::exception& e) {
12657       {
12658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12659       };
12660     } catch (...) {
12661       {
12662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12663       };
12664     }
12665   }
12666   jresult = result;
12667   return jresult;
12668 }
12669
12670
12671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12672   float jresult ;
12673   float arg1 ;
12674   float arg2 ;
12675   float result;
12676
12677   arg1 = (float)jarg1;
12678   arg2 = (float)jarg2;
12679   {
12680     try {
12681       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12682     } catch (std::out_of_range& e) {
12683       {
12684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12685       };
12686     } catch (std::exception& e) {
12687       {
12688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12689       };
12690     } catch (...) {
12691       {
12692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12693       };
12694     }
12695   }
12696   jresult = result;
12697   return jresult;
12698 }
12699
12700
12701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12702   unsigned int jresult ;
12703   float arg1 ;
12704   bool result;
12705
12706   arg1 = (float)jarg1;
12707   {
12708     try {
12709       result = (bool)Dali::EqualsZero(arg1);
12710     } catch (std::out_of_range& e) {
12711       {
12712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12713       };
12714     } catch (std::exception& e) {
12715       {
12716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12717       };
12718     } catch (...) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12721       };
12722     }
12723   }
12724   jresult = result;
12725   return jresult;
12726 }
12727
12728
12729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12730   unsigned int jresult ;
12731   float arg1 ;
12732   float arg2 ;
12733   bool result;
12734
12735   arg1 = (float)jarg1;
12736   arg2 = (float)jarg2;
12737   {
12738     try {
12739       result = (bool)Dali::Equals(arg1,arg2);
12740     } catch (std::out_of_range& e) {
12741       {
12742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12743       };
12744     } catch (std::exception& e) {
12745       {
12746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12747       };
12748     } catch (...) {
12749       {
12750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12751       };
12752     }
12753   }
12754   jresult = result;
12755   return jresult;
12756 }
12757
12758
12759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12760   unsigned int jresult ;
12761   float arg1 ;
12762   float arg2 ;
12763   float arg3 ;
12764   bool result;
12765
12766   arg1 = (float)jarg1;
12767   arg2 = (float)jarg2;
12768   arg3 = (float)jarg3;
12769   {
12770     try {
12771       result = (bool)Dali::Equals(arg1,arg2,arg3);
12772     } catch (std::out_of_range& e) {
12773       {
12774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12775       };
12776     } catch (std::exception& e) {
12777       {
12778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (...) {
12781       {
12782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12783       };
12784     }
12785   }
12786   jresult = result;
12787   return jresult;
12788 }
12789
12790
12791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12792   float jresult ;
12793   float arg1 ;
12794   int arg2 ;
12795   float result;
12796
12797   arg1 = (float)jarg1;
12798   arg2 = (int)jarg2;
12799   {
12800     try {
12801       result = (float)Dali::Round(arg1,arg2);
12802     } catch (std::out_of_range& e) {
12803       {
12804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12805       };
12806     } catch (std::exception& e) {
12807       {
12808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12809       };
12810     } catch (...) {
12811       {
12812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12813       };
12814     }
12815   }
12816   jresult = result;
12817   return jresult;
12818 }
12819
12820
12821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12822   float jresult ;
12823   float arg1 ;
12824   float arg2 ;
12825   float arg3 ;
12826   float result;
12827
12828   arg1 = (float)jarg1;
12829   arg2 = (float)jarg2;
12830   arg3 = (float)jarg3;
12831   {
12832     try {
12833       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12834     } catch (std::out_of_range& e) {
12835       {
12836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12837       };
12838     } catch (std::exception& e) {
12839       {
12840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12841       };
12842     } catch (...) {
12843       {
12844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12845       };
12846     }
12847   }
12848   jresult = result;
12849   return jresult;
12850 }
12851
12852
12853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12854   float jresult ;
12855   float arg1 ;
12856   float arg2 ;
12857   float arg3 ;
12858   float arg4 ;
12859   float result;
12860
12861   arg1 = (float)jarg1;
12862   arg2 = (float)jarg2;
12863   arg3 = (float)jarg3;
12864   arg4 = (float)jarg4;
12865   {
12866     try {
12867       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12868     } catch (std::out_of_range& e) {
12869       {
12870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12871       };
12872     } catch (std::exception& e) {
12873       {
12874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12875       };
12876     } catch (...) {
12877       {
12878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12879       };
12880     }
12881   }
12882   jresult = result;
12883   return jresult;
12884 }
12885
12886
12887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12888   int jresult ;
12889   int result;
12890
12891   result = (int)(int)Dali::Property::INVALID_INDEX;
12892   jresult = result;
12893   return jresult;
12894 }
12895
12896
12897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12898   int jresult ;
12899   int result;
12900
12901   result = (int)(int)Dali::Property::INVALID_KEY;
12902   jresult = result;
12903   return jresult;
12904 }
12905
12906
12907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12908   int jresult ;
12909   int result;
12910
12911   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12912   jresult = result;
12913   return jresult;
12914 }
12915
12916
12917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12918   void * jresult ;
12919   Dali::Handle *arg1 = 0 ;
12920   Dali::Property::Index arg2 ;
12921   Dali::Property *result = 0 ;
12922
12923   arg1 = (Dali::Handle *)jarg1;
12924   if (!arg1) {
12925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12926     return 0;
12927   }
12928   arg2 = (Dali::Property::Index)jarg2;
12929   {
12930     try {
12931       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12932     } catch (std::out_of_range& e) {
12933       {
12934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12935       };
12936     } catch (std::exception& e) {
12937       {
12938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (...) {
12941       {
12942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12943       };
12944     }
12945   }
12946   jresult = (void *)result;
12947   return jresult;
12948 }
12949
12950
12951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12952   void * jresult ;
12953   Dali::Handle *arg1 = 0 ;
12954   Dali::Property::Index arg2 ;
12955   int arg3 ;
12956   Dali::Property *result = 0 ;
12957
12958   arg1 = (Dali::Handle *)jarg1;
12959   if (!arg1) {
12960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12961     return 0;
12962   }
12963   arg2 = (Dali::Property::Index)jarg2;
12964   arg3 = (int)jarg3;
12965   {
12966     try {
12967       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12968     } catch (std::out_of_range& e) {
12969       {
12970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12971       };
12972     } catch (std::exception& e) {
12973       {
12974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12975       };
12976     } catch (...) {
12977       {
12978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12979       };
12980     }
12981   }
12982   jresult = (void *)result;
12983   return jresult;
12984 }
12985
12986
12987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
12988   void * jresult ;
12989   Dali::Handle *arg1 = 0 ;
12990   std::string *arg2 = 0 ;
12991   Dali::Property *result = 0 ;
12992
12993   arg1 = (Dali::Handle *)jarg1;
12994   if (!arg1) {
12995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12996     return 0;
12997   }
12998   if (!jarg2) {
12999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13000     return 0;
13001   }
13002   std::string arg2_str(jarg2);
13003   arg2 = &arg2_str;
13004   {
13005     try {
13006       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13007     } catch (std::out_of_range& e) {
13008       {
13009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13010       };
13011     } catch (std::exception& e) {
13012       {
13013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13014       };
13015     } catch (...) {
13016       {
13017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13018       };
13019     }
13020   }
13021   jresult = (void *)result;
13022
13023   //argout typemap for const std::string&
13024
13025   return jresult;
13026 }
13027
13028
13029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13030   void * jresult ;
13031   Dali::Handle *arg1 = 0 ;
13032   std::string *arg2 = 0 ;
13033   int arg3 ;
13034   Dali::Property *result = 0 ;
13035
13036   arg1 = (Dali::Handle *)jarg1;
13037   if (!arg1) {
13038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13039     return 0;
13040   }
13041   if (!jarg2) {
13042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13043     return 0;
13044   }
13045   std::string arg2_str(jarg2);
13046   arg2 = &arg2_str;
13047   arg3 = (int)jarg3;
13048   {
13049     try {
13050       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13051     } catch (std::out_of_range& e) {
13052       {
13053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13054       };
13055     } catch (std::exception& e) {
13056       {
13057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13058       };
13059     } catch (...) {
13060       {
13061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13062       };
13063     }
13064   }
13065   jresult = (void *)result;
13066
13067   //argout typemap for const std::string&
13068
13069   return jresult;
13070 }
13071
13072
13073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13074   Dali::Property *arg1 = (Dali::Property *) 0 ;
13075
13076   arg1 = (Dali::Property *)jarg1;
13077   {
13078     try {
13079       delete arg1;
13080     } catch (std::out_of_range& e) {
13081       {
13082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13083       };
13084     } catch (std::exception& e) {
13085       {
13086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13087       };
13088     } catch (...) {
13089       {
13090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13091       };
13092     }
13093   }
13094 }
13095
13096
13097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13098   Dali::Property *arg1 = (Dali::Property *) 0 ;
13099   Dali::Handle *arg2 = 0 ;
13100
13101   arg1 = (Dali::Property *)jarg1;
13102   arg2 = (Dali::Handle *)jarg2;
13103   if (!arg2) {
13104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13105     return ;
13106   }
13107   if (arg1) (arg1)->object = *arg2;
13108 }
13109
13110
13111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13112   void * jresult ;
13113   Dali::Property *arg1 = (Dali::Property *) 0 ;
13114   Dali::Handle *result = 0 ;
13115
13116   arg1 = (Dali::Property *)jarg1;
13117   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13118   jresult = (void *)result;
13119   return jresult;
13120 }
13121
13122
13123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13124   Dali::Property *arg1 = (Dali::Property *) 0 ;
13125   Dali::Property::Index arg2 ;
13126
13127   arg1 = (Dali::Property *)jarg1;
13128   arg2 = (Dali::Property::Index)jarg2;
13129   if (arg1) (arg1)->propertyIndex = arg2;
13130 }
13131
13132
13133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13134   int jresult ;
13135   Dali::Property *arg1 = (Dali::Property *) 0 ;
13136   Dali::Property::Index result;
13137
13138   arg1 = (Dali::Property *)jarg1;
13139   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13140   jresult = result;
13141   return jresult;
13142 }
13143
13144
13145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13146   Dali::Property *arg1 = (Dali::Property *) 0 ;
13147   int arg2 ;
13148
13149   arg1 = (Dali::Property *)jarg1;
13150   arg2 = (int)jarg2;
13151   if (arg1) (arg1)->componentIndex = arg2;
13152 }
13153
13154
13155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13156   int jresult ;
13157   Dali::Property *arg1 = (Dali::Property *) 0 ;
13158   int result;
13159
13160   arg1 = (Dali::Property *)jarg1;
13161   result = (int) ((arg1)->componentIndex);
13162   jresult = result;
13163   return jresult;
13164 }
13165
13166
13167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13168   void * jresult ;
13169   Dali::Property::Array *result = 0 ;
13170
13171   {
13172     try {
13173       result = (Dali::Property::Array *)new Dali::Property::Array();
13174     } catch (std::out_of_range& e) {
13175       {
13176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13177       };
13178     } catch (std::exception& e) {
13179       {
13180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13181       };
13182     } catch (...) {
13183       {
13184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13185       };
13186     }
13187   }
13188   jresult = (void *)result;
13189   return jresult;
13190 }
13191
13192
13193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13194   void * jresult ;
13195   Dali::Property::Array *arg1 = 0 ;
13196   Dali::Property::Array *result = 0 ;
13197
13198   arg1 = (Dali::Property::Array *)jarg1;
13199   if (!arg1) {
13200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13201     return 0;
13202   }
13203   {
13204     try {
13205       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13206     } catch (std::out_of_range& e) {
13207       {
13208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13209       };
13210     } catch (std::exception& e) {
13211       {
13212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13213       };
13214     } catch (...) {
13215       {
13216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13217       };
13218     }
13219   }
13220   jresult = (void *)result;
13221   return jresult;
13222 }
13223
13224
13225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13226   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13227
13228   arg1 = (Dali::Property::Array *)jarg1;
13229   {
13230     try {
13231       delete arg1;
13232     } catch (std::out_of_range& e) {
13233       {
13234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13235       };
13236     } catch (std::exception& e) {
13237       {
13238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13239       };
13240     } catch (...) {
13241       {
13242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13243       };
13244     }
13245   }
13246 }
13247
13248
13249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13250   unsigned long jresult ;
13251   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13252   Dali::Property::Array::SizeType result;
13253
13254   arg1 = (Dali::Property::Array *)jarg1;
13255   {
13256     try {
13257       result = ((Dali::Property::Array const *)arg1)->Size();
13258     } catch (std::out_of_range& e) {
13259       {
13260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13261       };
13262     } catch (std::exception& e) {
13263       {
13264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13265       };
13266     } catch (...) {
13267       {
13268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13269       };
13270     }
13271   }
13272   jresult = (unsigned long)result;
13273   return jresult;
13274 }
13275
13276
13277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13278   unsigned long jresult ;
13279   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13280   Dali::Property::Array::SizeType result;
13281
13282   arg1 = (Dali::Property::Array *)jarg1;
13283   {
13284     try {
13285       result = ((Dali::Property::Array const *)arg1)->Count();
13286     } catch (std::out_of_range& e) {
13287       {
13288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13289       };
13290     } catch (std::exception& e) {
13291       {
13292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13293       };
13294     } catch (...) {
13295       {
13296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13297       };
13298     }
13299   }
13300   jresult = (unsigned long)result;
13301   return jresult;
13302 }
13303
13304
13305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13306   unsigned int jresult ;
13307   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13308   bool result;
13309
13310   arg1 = (Dali::Property::Array *)jarg1;
13311   {
13312     try {
13313       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13314     } catch (std::out_of_range& e) {
13315       {
13316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13317       };
13318     } catch (std::exception& e) {
13319       {
13320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13321       };
13322     } catch (...) {
13323       {
13324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13325       };
13326     }
13327   }
13328   jresult = result;
13329   return jresult;
13330 }
13331
13332
13333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13334   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13335
13336   arg1 = (Dali::Property::Array *)jarg1;
13337   {
13338     try {
13339       (arg1)->Clear();
13340     } catch (std::out_of_range& e) {
13341       {
13342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13343       };
13344     } catch (std::exception& e) {
13345       {
13346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (...) {
13349       {
13350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13351       };
13352     }
13353   }
13354 }
13355
13356
13357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13358   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13359   Dali::Property::Array::SizeType arg2 ;
13360
13361   arg1 = (Dali::Property::Array *)jarg1;
13362   arg2 = (Dali::Property::Array::SizeType)jarg2;
13363   {
13364     try {
13365       (arg1)->Reserve(arg2);
13366     } catch (std::out_of_range& e) {
13367       {
13368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13369       };
13370     } catch (std::exception& e) {
13371       {
13372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13373       };
13374     } catch (...) {
13375       {
13376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13377       };
13378     }
13379   }
13380 }
13381
13382
13383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13384   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13385   Dali::Property::Array::SizeType arg2 ;
13386
13387   arg1 = (Dali::Property::Array *)jarg1;
13388   arg2 = (Dali::Property::Array::SizeType)jarg2;
13389   {
13390     try {
13391       (arg1)->Resize(arg2);
13392     } catch (std::out_of_range& e) {
13393       {
13394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13395       };
13396     } catch (std::exception& e) {
13397       {
13398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13399       };
13400     } catch (...) {
13401       {
13402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13403       };
13404     }
13405   }
13406 }
13407
13408
13409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13410   unsigned long jresult ;
13411   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13412   Dali::Property::Array::SizeType result;
13413
13414   arg1 = (Dali::Property::Array *)jarg1;
13415   {
13416     try {
13417       result = (arg1)->Capacity();
13418     } catch (std::out_of_range& e) {
13419       {
13420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (std::exception& e) {
13423       {
13424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432   jresult = (unsigned long)result;
13433   return jresult;
13434 }
13435
13436
13437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13438   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13439   Dali::Property::Value *arg2 = 0 ;
13440
13441   arg1 = (Dali::Property::Array *)jarg1;
13442   arg2 = (Dali::Property::Value *)jarg2;
13443   if (!arg2) {
13444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13445     return ;
13446   }
13447   {
13448     try {
13449       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13450     } catch (std::out_of_range& e) {
13451       {
13452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13453       };
13454     } catch (std::exception& e) {
13455       {
13456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13457       };
13458     } catch (...) {
13459       {
13460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13461       };
13462     }
13463   }
13464 }
13465
13466
13467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13468   void * jresult ;
13469   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13470   Dali::Property::Value *arg2 = 0 ;
13471   Dali::Property::Array *result = 0 ;
13472
13473   arg1 = (Dali::Property::Array *)jarg1;
13474   arg2 = (Dali::Property::Value *)jarg2;
13475   if (!arg2) {
13476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13477     return 0;
13478   }
13479   {
13480     try {
13481       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13482     } catch (std::out_of_range& e) {
13483       {
13484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13485       };
13486     } catch (std::exception& e) {
13487       {
13488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (...) {
13491       {
13492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13493       };
13494     }
13495   }
13496   jresult = (void *)result;
13497   return jresult;
13498 }
13499
13500
13501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13502   void * jresult ;
13503   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13504   Dali::Property::Array::SizeType arg2 ;
13505   Dali::Property::Value *result = 0 ;
13506
13507   arg1 = (Dali::Property::Array *)jarg1;
13508   arg2 = (Dali::Property::Array::SizeType)jarg2;
13509   {
13510     try {
13511       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13512     } catch (std::out_of_range& e) {
13513       {
13514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13515       };
13516     } catch (std::exception& e) {
13517       {
13518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13519       };
13520     } catch (...) {
13521       {
13522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13523       };
13524     }
13525   }
13526   jresult = (void *)result;
13527   return jresult;
13528 }
13529
13530
13531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13532   void * jresult ;
13533   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13534   Dali::Property::Array::SizeType arg2 ;
13535   Dali::Property::Value *result = 0 ;
13536
13537   arg1 = (Dali::Property::Array *)jarg1;
13538   arg2 = (Dali::Property::Array::SizeType)jarg2;
13539   {
13540     try {
13541       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13542     } catch (std::out_of_range& e) {
13543       {
13544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13545       };
13546     } catch (std::exception& e) {
13547       {
13548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13549       };
13550     } catch (...) {
13551       {
13552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13553       };
13554     }
13555   }
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13564   Dali::Property::Array *arg2 = 0 ;
13565   Dali::Property::Array *result = 0 ;
13566
13567   arg1 = (Dali::Property::Array *)jarg1;
13568   arg2 = (Dali::Property::Array *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (...) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13587       };
13588     }
13589   }
13590   jresult = (void *)result;
13591   return jresult;
13592 }
13593
13594
13595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13596   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13597   enum Dali::Property::Key::Type arg2 ;
13598
13599   arg1 = (Dali::Property::Key *)jarg1;
13600   arg2 = (enum Dali::Property::Key::Type)jarg2;
13601   if (arg1) (arg1)->type = arg2;
13602 }
13603
13604
13605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13606   int jresult ;
13607   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13608   enum Dali::Property::Key::Type result;
13609
13610   arg1 = (Dali::Property::Key *)jarg1;
13611   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13612   jresult = (int)result;
13613   return jresult;
13614 }
13615
13616
13617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13618   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13619   Dali::Property::Index arg2 ;
13620
13621   arg1 = (Dali::Property::Key *)jarg1;
13622   arg2 = (Dali::Property::Index)jarg2;
13623   if (arg1) (arg1)->indexKey = arg2;
13624 }
13625
13626
13627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13628   int jresult ;
13629   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13630   Dali::Property::Index result;
13631
13632   arg1 = (Dali::Property::Key *)jarg1;
13633   result = (Dali::Property::Index) ((arg1)->indexKey);
13634   jresult = result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13640   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13641   std::string *arg2 = 0 ;
13642
13643   arg1 = (Dali::Property::Key *)jarg1;
13644   if (!jarg2) {
13645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13646     return ;
13647   }
13648   std::string arg2_str(jarg2);
13649   arg2 = &arg2_str;
13650   if (arg1) (arg1)->stringKey = *arg2;
13651
13652   //argout typemap for const std::string&
13653
13654 }
13655
13656
13657 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13658   char * jresult ;
13659   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13660   std::string *result = 0 ;
13661
13662   arg1 = (Dali::Property::Key *)jarg1;
13663   result = (std::string *) & ((arg1)->stringKey);
13664   jresult = SWIG_csharp_string_callback(result->c_str());
13665   return jresult;
13666 }
13667
13668
13669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13670   void * jresult ;
13671   std::string *arg1 = 0 ;
13672   Dali::Property::Key *result = 0 ;
13673
13674   if (!jarg1) {
13675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13676     return 0;
13677   }
13678   std::string arg1_str(jarg1);
13679   arg1 = &arg1_str;
13680   {
13681     try {
13682       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13683     } catch (std::out_of_range& e) {
13684       {
13685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13686       };
13687     } catch (std::exception& e) {
13688       {
13689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13690       };
13691     } catch (...) {
13692       {
13693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13694       };
13695     }
13696   }
13697   jresult = (void *)result;
13698
13699   //argout typemap for const std::string&
13700
13701   return jresult;
13702 }
13703
13704
13705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13706   void * jresult ;
13707   Dali::Property::Index arg1 ;
13708   Dali::Property::Key *result = 0 ;
13709
13710   arg1 = (Dali::Property::Index)jarg1;
13711   {
13712     try {
13713       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13714     } catch (std::out_of_range& e) {
13715       {
13716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13717       };
13718     } catch (std::exception& e) {
13719       {
13720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13721       };
13722     } catch (...) {
13723       {
13724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13725       };
13726     }
13727   }
13728   jresult = (void *)result;
13729   return jresult;
13730 }
13731
13732
13733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13734   unsigned int jresult ;
13735   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13736   std::string *arg2 = 0 ;
13737   bool result;
13738
13739   arg1 = (Dali::Property::Key *)jarg1;
13740   if (!jarg2) {
13741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13742     return 0;
13743   }
13744   std::string arg2_str(jarg2);
13745   arg2 = &arg2_str;
13746   {
13747     try {
13748       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13749     } catch (std::out_of_range& e) {
13750       {
13751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13752       };
13753     } catch (std::exception& e) {
13754       {
13755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13756       };
13757     } catch (...) {
13758       {
13759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13760       };
13761     }
13762   }
13763   jresult = result;
13764
13765   //argout typemap for const std::string&
13766
13767   return jresult;
13768 }
13769
13770
13771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13772   unsigned int jresult ;
13773   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13774   Dali::Property::Index arg2 ;
13775   bool result;
13776
13777   arg1 = (Dali::Property::Key *)jarg1;
13778   arg2 = (Dali::Property::Index)jarg2;
13779   {
13780     try {
13781       result = (bool)(arg1)->operator ==(arg2);
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (...) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13793       };
13794     }
13795   }
13796   jresult = result;
13797   return jresult;
13798 }
13799
13800
13801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13802   unsigned int jresult ;
13803   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13804   Dali::Property::Key *arg2 = 0 ;
13805   bool result;
13806
13807   arg1 = (Dali::Property::Key *)jarg1;
13808   arg2 = (Dali::Property::Key *)jarg2;
13809   if (!arg2) {
13810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13811     return 0;
13812   }
13813   {
13814     try {
13815       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13816     } catch (std::out_of_range& e) {
13817       {
13818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13819       };
13820     } catch (std::exception& e) {
13821       {
13822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (...) {
13825       {
13826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13827       };
13828     }
13829   }
13830   jresult = result;
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13836   unsigned int jresult ;
13837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13838   std::string *arg2 = 0 ;
13839   bool result;
13840
13841   arg1 = (Dali::Property::Key *)jarg1;
13842   if (!jarg2) {
13843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13844     return 0;
13845   }
13846   std::string arg2_str(jarg2);
13847   arg2 = &arg2_str;
13848   {
13849     try {
13850       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13851     } catch (std::out_of_range& e) {
13852       {
13853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13854       };
13855     } catch (std::exception& e) {
13856       {
13857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (...) {
13860       {
13861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13862       };
13863     }
13864   }
13865   jresult = result;
13866
13867   //argout typemap for const std::string&
13868
13869   return jresult;
13870 }
13871
13872
13873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13874   unsigned int jresult ;
13875   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13876   Dali::Property::Index arg2 ;
13877   bool result;
13878
13879   arg1 = (Dali::Property::Key *)jarg1;
13880   arg2 = (Dali::Property::Index)jarg2;
13881   {
13882     try {
13883       result = (bool)(arg1)->operator !=(arg2);
13884     } catch (std::out_of_range& e) {
13885       {
13886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (std::exception& e) {
13889       {
13890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (...) {
13893       {
13894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13895       };
13896     }
13897   }
13898   jresult = result;
13899   return jresult;
13900 }
13901
13902
13903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13904   unsigned int jresult ;
13905   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13906   Dali::Property::Key *arg2 = 0 ;
13907   bool result;
13908
13909   arg1 = (Dali::Property::Key *)jarg1;
13910   arg2 = (Dali::Property::Key *)jarg2;
13911   if (!arg2) {
13912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13913     return 0;
13914   }
13915   {
13916     try {
13917       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13918     } catch (std::out_of_range& e) {
13919       {
13920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (std::exception& e) {
13923       {
13924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932   jresult = result;
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13938   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13939
13940   arg1 = (Dali::Property::Key *)jarg1;
13941   {
13942     try {
13943       delete arg1;
13944     } catch (std::out_of_range& e) {
13945       {
13946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13947       };
13948     } catch (std::exception& e) {
13949       {
13950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13951       };
13952     } catch (...) {
13953       {
13954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13955       };
13956     }
13957   }
13958 }
13959
13960
13961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13962   void * jresult ;
13963   Dali::Property::Map *result = 0 ;
13964
13965   {
13966     try {
13967       result = (Dali::Property::Map *)new Dali::Property::Map();
13968     } catch (std::out_of_range& e) {
13969       {
13970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13971       };
13972     } catch (std::exception& e) {
13973       {
13974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13975       };
13976     } catch (...) {
13977       {
13978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13979       };
13980     }
13981   }
13982   jresult = (void *)result;
13983   return jresult;
13984 }
13985
13986
13987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
13988   void * jresult ;
13989   Dali::Property::Map *arg1 = 0 ;
13990   Dali::Property::Map *result = 0 ;
13991
13992   arg1 = (Dali::Property::Map *)jarg1;
13993   if (!arg1) {
13994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
13995     return 0;
13996   }
13997   {
13998     try {
13999       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14000     } catch (std::out_of_range& e) {
14001       {
14002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14003       };
14004     } catch (std::exception& e) {
14005       {
14006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14007       };
14008     } catch (...) {
14009       {
14010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14011       };
14012     }
14013   }
14014   jresult = (void *)result;
14015   return jresult;
14016 }
14017
14018
14019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14020   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14021
14022   arg1 = (Dali::Property::Map *)jarg1;
14023   {
14024     try {
14025       delete arg1;
14026     } catch (std::out_of_range& e) {
14027       {
14028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14029       };
14030     } catch (std::exception& e) {
14031       {
14032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14033       };
14034     } catch (...) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14037       };
14038     }
14039   }
14040 }
14041
14042
14043 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14044   unsigned long jresult ;
14045   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14046   Dali::Property::Map::SizeType result;
14047
14048   arg1 = (Dali::Property::Map *)jarg1;
14049   {
14050     try {
14051       result = ((Dali::Property::Map const *)arg1)->Count();
14052     } catch (std::out_of_range& e) {
14053       {
14054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14055       };
14056     } catch (std::exception& e) {
14057       {
14058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (...) {
14061       {
14062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14063       };
14064     }
14065   }
14066   jresult = (unsigned long)result;
14067   return jresult;
14068 }
14069
14070
14071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14072   unsigned int jresult ;
14073   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14074   bool result;
14075
14076   arg1 = (Dali::Property::Map *)jarg1;
14077   {
14078     try {
14079       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14080     } catch (std::out_of_range& e) {
14081       {
14082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14083       };
14084     } catch (std::exception& e) {
14085       {
14086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14087       };
14088     } catch (...) {
14089       {
14090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14091       };
14092     }
14093   }
14094   jresult = result;
14095   return jresult;
14096 }
14097
14098
14099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14100   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14101   char *arg2 = (char *) 0 ;
14102   Dali::Property::Value *arg3 = 0 ;
14103
14104   arg1 = (Dali::Property::Map *)jarg1;
14105   arg2 = (char *)jarg2;
14106   arg3 = (Dali::Property::Value *)jarg3;
14107   if (!arg3) {
14108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14109     return ;
14110   }
14111   {
14112     try {
14113       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14114     } catch (std::out_of_range& e) {
14115       {
14116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14117       };
14118     } catch (std::exception& e) {
14119       {
14120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14121       };
14122     } catch (...) {
14123       {
14124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14125       };
14126     }
14127   }
14128 }
14129
14130
14131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14132   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14133   Dali::Property::Index arg2 ;
14134   Dali::Property::Value *arg3 = 0 ;
14135
14136   arg1 = (Dali::Property::Map *)jarg1;
14137   arg2 = (Dali::Property::Index)jarg2;
14138   arg3 = (Dali::Property::Value *)jarg3;
14139   if (!arg3) {
14140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14141     return ;
14142   }
14143   {
14144     try {
14145       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14146     } catch (std::out_of_range& e) {
14147       {
14148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14149       };
14150     } catch (std::exception& e) {
14151       {
14152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14153       };
14154     } catch (...) {
14155       {
14156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14157       };
14158     }
14159   }
14160 }
14161
14162
14163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14164   void * jresult ;
14165   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14166   char *arg2 = (char *) 0 ;
14167   Dali::Property::Value *arg3 = 0 ;
14168   Dali::Property::Map *result = 0 ;
14169
14170   arg1 = (Dali::Property::Map *)jarg1;
14171   arg2 = (char *)jarg2;
14172   arg3 = (Dali::Property::Value *)jarg3;
14173   if (!arg3) {
14174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14175     return 0;
14176   }
14177   {
14178     try {
14179       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14180     } catch (std::out_of_range& e) {
14181       {
14182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14183       };
14184     } catch (std::exception& e) {
14185       {
14186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14187       };
14188     } catch (...) {
14189       {
14190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14191       };
14192     }
14193   }
14194   jresult = (void *)result;
14195   return jresult;
14196 }
14197
14198
14199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14200   void * jresult ;
14201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14202   Dali::Property::Index arg2 ;
14203   Dali::Property::Value *arg3 = 0 ;
14204   Dali::Property::Map *result = 0 ;
14205
14206   arg1 = (Dali::Property::Map *)jarg1;
14207   arg2 = (Dali::Property::Index)jarg2;
14208   arg3 = (Dali::Property::Value *)jarg3;
14209   if (!arg3) {
14210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14211     return 0;
14212   }
14213   {
14214     try {
14215       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14216     } catch (std::out_of_range& e) {
14217       {
14218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14219       };
14220     } catch (std::exception& e) {
14221       {
14222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14223       };
14224     } catch (...) {
14225       {
14226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14227       };
14228     }
14229   }
14230   jresult = (void *)result;
14231   return jresult;
14232 }
14233
14234
14235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14236   void * jresult ;
14237   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14238   Dali::Property::Map::SizeType arg2 ;
14239   Dali::Property::Value *result = 0 ;
14240
14241   arg1 = (Dali::Property::Map *)jarg1;
14242   arg2 = (Dali::Property::Map::SizeType)jarg2;
14243   {
14244     try {
14245       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14246     } catch (std::out_of_range& e) {
14247       {
14248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14249       };
14250     } catch (std::exception& e) {
14251       {
14252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (...) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14257       };
14258     }
14259   }
14260   jresult = (void *)result;
14261   return jresult;
14262 }
14263
14264
14265 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14266   char * jresult ;
14267   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14268   Dali::Property::Map::SizeType arg2 ;
14269   std::string *result = 0 ;
14270
14271   arg1 = (Dali::Property::Map *)jarg1;
14272   arg2 = (Dali::Property::Map::SizeType)jarg2;
14273   {
14274     try {
14275       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14276     } catch (std::out_of_range& e) {
14277       {
14278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14279       };
14280     } catch (std::exception& e) {
14281       {
14282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (...) {
14285       {
14286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14287       };
14288     }
14289   }
14290   jresult = SWIG_csharp_string_callback(result->c_str());
14291   return jresult;
14292 }
14293
14294
14295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14296   void * jresult ;
14297   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14298   Dali::Property::Map::SizeType arg2 ;
14299   SwigValueWrapper< Dali::Property::Key > result;
14300
14301   arg1 = (Dali::Property::Map *)jarg1;
14302   arg2 = (Dali::Property::Map::SizeType)jarg2;
14303   {
14304     try {
14305       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14306     } catch (std::out_of_range& e) {
14307       {
14308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14309       };
14310     } catch (std::exception& e) {
14311       {
14312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14313       };
14314     } catch (...) {
14315       {
14316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14317       };
14318     }
14319   }
14320   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14321   return jresult;
14322 }
14323
14324
14325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14326   void * jresult ;
14327   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14328   Dali::Property::Map::SizeType arg2 ;
14329   StringValuePair *result = 0 ;
14330
14331   arg1 = (Dali::Property::Map *)jarg1;
14332   arg2 = (Dali::Property::Map::SizeType)jarg2;
14333   {
14334     try {
14335       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14336     } catch (std::out_of_range& e) {
14337       {
14338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14339       };
14340     } catch (std::exception& e) {
14341       {
14342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14343       };
14344     } catch (...) {
14345       {
14346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14347       };
14348     }
14349   }
14350   jresult = (void *)result;
14351   return jresult;
14352 }
14353
14354
14355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14356   void * jresult ;
14357   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14358   char *arg2 = (char *) 0 ;
14359   Dali::Property::Value *result = 0 ;
14360
14361   arg1 = (Dali::Property::Map *)jarg1;
14362   arg2 = (char *)jarg2;
14363   {
14364     try {
14365       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14366     } catch (std::out_of_range& e) {
14367       {
14368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14369       };
14370     } catch (std::exception& e) {
14371       {
14372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14373       };
14374     } catch (...) {
14375       {
14376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14377       };
14378     }
14379   }
14380   jresult = (void *)result;
14381   return jresult;
14382 }
14383
14384
14385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14386   void * jresult ;
14387   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14388   Dali::Property::Index arg2 ;
14389   Dali::Property::Value *result = 0 ;
14390
14391   arg1 = (Dali::Property::Map *)jarg1;
14392   arg2 = (Dali::Property::Index)jarg2;
14393   {
14394     try {
14395       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14396     } catch (std::out_of_range& e) {
14397       {
14398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14399       };
14400     } catch (std::exception& e) {
14401       {
14402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14403       };
14404     } catch (...) {
14405       {
14406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14407       };
14408     }
14409   }
14410   jresult = (void *)result;
14411   return jresult;
14412 }
14413
14414
14415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14416   void * jresult ;
14417   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14418   Dali::Property::Index arg2 ;
14419   std::string *arg3 = 0 ;
14420   Dali::Property::Value *result = 0 ;
14421
14422   arg1 = (Dali::Property::Map *)jarg1;
14423   arg2 = (Dali::Property::Index)jarg2;
14424   if (!jarg3) {
14425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14426     return 0;
14427   }
14428   std::string arg3_str(jarg3);
14429   arg3 = &arg3_str;
14430   {
14431     try {
14432       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14433     } catch (std::out_of_range& e) {
14434       {
14435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14436       };
14437     } catch (std::exception& e) {
14438       {
14439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14440       };
14441     } catch (...) {
14442       {
14443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14444       };
14445     }
14446   }
14447   jresult = (void *)result;
14448
14449   //argout typemap for const std::string&
14450
14451   return jresult;
14452 }
14453
14454
14455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14456   void * jresult ;
14457   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14458   std::string *arg2 = 0 ;
14459   Dali::Property::Type arg3 ;
14460   Dali::Property::Value *result = 0 ;
14461
14462   arg1 = (Dali::Property::Map *)jarg1;
14463   if (!jarg2) {
14464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14465     return 0;
14466   }
14467   std::string arg2_str(jarg2);
14468   arg2 = &arg2_str;
14469   arg3 = (Dali::Property::Type)jarg3;
14470   {
14471     try {
14472       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14473     } catch (std::out_of_range& e) {
14474       {
14475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14476       };
14477     } catch (std::exception& e) {
14478       {
14479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14480       };
14481     } catch (...) {
14482       {
14483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14484       };
14485     }
14486   }
14487   jresult = (void *)result;
14488
14489   //argout typemap for const std::string&
14490
14491   return jresult;
14492 }
14493
14494
14495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14496   void * jresult ;
14497   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14498   Dali::Property::Index arg2 ;
14499   Dali::Property::Type arg3 ;
14500   Dali::Property::Value *result = 0 ;
14501
14502   arg1 = (Dali::Property::Map *)jarg1;
14503   arg2 = (Dali::Property::Index)jarg2;
14504   arg3 = (Dali::Property::Type)jarg3;
14505   {
14506     try {
14507       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14508     } catch (std::out_of_range& e) {
14509       {
14510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14511       };
14512     } catch (std::exception& e) {
14513       {
14514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (...) {
14517       {
14518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14519       };
14520     }
14521   }
14522   jresult = (void *)result;
14523   return jresult;
14524 }
14525
14526
14527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14528   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14529
14530   arg1 = (Dali::Property::Map *)jarg1;
14531   {
14532     try {
14533       (arg1)->Clear();
14534     } catch (std::out_of_range& e) {
14535       {
14536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14537       };
14538     } catch (std::exception& e) {
14539       {
14540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14541       };
14542     } catch (...) {
14543       {
14544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14545       };
14546     }
14547   }
14548 }
14549
14550
14551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14552   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14553   Dali::Property::Map *arg2 = 0 ;
14554
14555   arg1 = (Dali::Property::Map *)jarg1;
14556   arg2 = (Dali::Property::Map *)jarg2;
14557   if (!arg2) {
14558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14559     return ;
14560   }
14561   {
14562     try {
14563       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14564     } catch (std::out_of_range& e) {
14565       {
14566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14567       };
14568     } catch (std::exception& e) {
14569       {
14570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14571       };
14572     } catch (...) {
14573       {
14574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14575       };
14576     }
14577   }
14578 }
14579
14580
14581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14582   void * jresult ;
14583   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14584   std::string *arg2 = 0 ;
14585   Dali::Property::Value *result = 0 ;
14586
14587   arg1 = (Dali::Property::Map *)jarg1;
14588   if (!jarg2) {
14589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14590     return 0;
14591   }
14592   std::string arg2_str(jarg2);
14593   arg2 = &arg2_str;
14594   {
14595     try {
14596       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14597     } catch (std::out_of_range& e) {
14598       {
14599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14600       };
14601     } catch (std::exception& e) {
14602       {
14603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14604       };
14605     } catch (...) {
14606       {
14607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14608       };
14609     }
14610   }
14611   jresult = (void *)result;
14612
14613   //argout typemap for const std::string&
14614
14615   return jresult;
14616 }
14617
14618
14619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14620   void * jresult ;
14621   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14622   Dali::Property::Index arg2 ;
14623   Dali::Property::Value *result = 0 ;
14624
14625   arg1 = (Dali::Property::Map *)jarg1;
14626   arg2 = (Dali::Property::Index)jarg2;
14627   {
14628     try {
14629       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14630     } catch (std::out_of_range& e) {
14631       {
14632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (std::exception& e) {
14635       {
14636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (...) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14641       };
14642     }
14643   }
14644   jresult = (void *)result;
14645   return jresult;
14646 }
14647
14648
14649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14650   void * jresult ;
14651   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14652   Dali::Property::Map *arg2 = 0 ;
14653   Dali::Property::Map *result = 0 ;
14654
14655   arg1 = (Dali::Property::Map *)jarg1;
14656   arg2 = (Dali::Property::Map *)jarg2;
14657   if (!arg2) {
14658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14659     return 0;
14660   }
14661   {
14662     try {
14663       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14664     } catch (std::out_of_range& e) {
14665       {
14666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14667       };
14668     } catch (std::exception& e) {
14669       {
14670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14671       };
14672     } catch (...) {
14673       {
14674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14675       };
14676     }
14677   }
14678   jresult = (void *)result;
14679   return jresult;
14680 }
14681
14682
14683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14684   void * jresult ;
14685   Dali::Property::Value *result = 0 ;
14686
14687   {
14688     try {
14689       result = (Dali::Property::Value *)new Dali::Property::Value();
14690     } catch (std::out_of_range& e) {
14691       {
14692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14693       };
14694     } catch (std::exception& e) {
14695       {
14696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14697       };
14698     } catch (...) {
14699       {
14700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14701       };
14702     }
14703   }
14704   jresult = (void *)result;
14705   return jresult;
14706 }
14707
14708
14709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14710   void * jresult ;
14711   bool arg1 ;
14712   Dali::Property::Value *result = 0 ;
14713
14714   arg1 = jarg1 ? true : false;
14715   {
14716     try {
14717       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14718     } catch (std::out_of_range& e) {
14719       {
14720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14721       };
14722     } catch (std::exception& e) {
14723       {
14724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14725       };
14726     } catch (...) {
14727       {
14728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14729       };
14730     }
14731   }
14732   jresult = (void *)result;
14733   return jresult;
14734 }
14735
14736
14737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14738   void * jresult ;
14739   int arg1 ;
14740   Dali::Property::Value *result = 0 ;
14741
14742   arg1 = (int)jarg1;
14743   {
14744     try {
14745       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14746     } catch (std::out_of_range& e) {
14747       {
14748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14749       };
14750     } catch (std::exception& e) {
14751       {
14752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14753       };
14754     } catch (...) {
14755       {
14756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14757       };
14758     }
14759   }
14760   jresult = (void *)result;
14761   return jresult;
14762 }
14763
14764
14765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14766   void * jresult ;
14767   float arg1 ;
14768   Dali::Property::Value *result = 0 ;
14769
14770   arg1 = (float)jarg1;
14771   {
14772     try {
14773       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14774     } catch (std::out_of_range& e) {
14775       {
14776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (std::exception& e) {
14779       {
14780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788   jresult = (void *)result;
14789   return jresult;
14790 }
14791
14792
14793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14794   void * jresult ;
14795   Dali::Vector2 *arg1 = 0 ;
14796   Dali::Property::Value *result = 0 ;
14797
14798   arg1 = (Dali::Vector2 *)jarg1;
14799   if (!arg1) {
14800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14801     return 0;
14802   }
14803   {
14804     try {
14805       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14806     } catch (std::out_of_range& e) {
14807       {
14808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14809       };
14810     } catch (std::exception& e) {
14811       {
14812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14813       };
14814     } catch (...) {
14815       {
14816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14817       };
14818     }
14819   }
14820   jresult = (void *)result;
14821   return jresult;
14822 }
14823
14824
14825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14826   void * jresult ;
14827   Dali::Vector3 *arg1 = 0 ;
14828   Dali::Property::Value *result = 0 ;
14829
14830   arg1 = (Dali::Vector3 *)jarg1;
14831   if (!arg1) {
14832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14833     return 0;
14834   }
14835   {
14836     try {
14837       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14838     } catch (std::out_of_range& e) {
14839       {
14840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14841       };
14842     } catch (std::exception& e) {
14843       {
14844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14845       };
14846     } catch (...) {
14847       {
14848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14849       };
14850     }
14851   }
14852   jresult = (void *)result;
14853   return jresult;
14854 }
14855
14856
14857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14858   void * jresult ;
14859   Dali::Vector4 *arg1 = 0 ;
14860   Dali::Property::Value *result = 0 ;
14861
14862   arg1 = (Dali::Vector4 *)jarg1;
14863   if (!arg1) {
14864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14865     return 0;
14866   }
14867   {
14868     try {
14869       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14870     } catch (std::out_of_range& e) {
14871       {
14872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14873       };
14874     } catch (std::exception& e) {
14875       {
14876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (...) {
14879       {
14880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14881       };
14882     }
14883   }
14884   jresult = (void *)result;
14885   return jresult;
14886 }
14887
14888
14889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14890   void * jresult ;
14891   Dali::Matrix3 *arg1 = 0 ;
14892   Dali::Property::Value *result = 0 ;
14893
14894   arg1 = (Dali::Matrix3 *)jarg1;
14895   if (!arg1) {
14896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14897     return 0;
14898   }
14899   {
14900     try {
14901       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14902     } catch (std::out_of_range& e) {
14903       {
14904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14905       };
14906     } catch (std::exception& e) {
14907       {
14908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14909       };
14910     } catch (...) {
14911       {
14912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14913       };
14914     }
14915   }
14916   jresult = (void *)result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14922   void * jresult ;
14923   Dali::Matrix *arg1 = 0 ;
14924   Dali::Property::Value *result = 0 ;
14925
14926   arg1 = (Dali::Matrix *)jarg1;
14927   if (!arg1) {
14928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14929     return 0;
14930   }
14931   {
14932     try {
14933       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14934     } catch (std::out_of_range& e) {
14935       {
14936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14937       };
14938     } catch (std::exception& e) {
14939       {
14940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (...) {
14943       {
14944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14945       };
14946     }
14947   }
14948   jresult = (void *)result;
14949   return jresult;
14950 }
14951
14952
14953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14954   void * jresult ;
14955   Dali::Rect< int > *arg1 = 0 ;
14956   Dali::Property::Value *result = 0 ;
14957
14958   arg1 = (Dali::Rect< int > *)jarg1;
14959   if (!arg1) {
14960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14961     return 0;
14962   }
14963   {
14964     try {
14965       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14966     } catch (std::out_of_range& e) {
14967       {
14968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14969       };
14970     } catch (std::exception& e) {
14971       {
14972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14973       };
14974     } catch (...) {
14975       {
14976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14977       };
14978     }
14979   }
14980   jresult = (void *)result;
14981   return jresult;
14982 }
14983
14984
14985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
14986   void * jresult ;
14987   Dali::AngleAxis *arg1 = 0 ;
14988   Dali::Property::Value *result = 0 ;
14989
14990   arg1 = (Dali::AngleAxis *)jarg1;
14991   if (!arg1) {
14992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14993     return 0;
14994   }
14995   {
14996     try {
14997       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
14998     } catch (std::out_of_range& e) {
14999       {
15000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15001       };
15002     } catch (std::exception& e) {
15003       {
15004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (...) {
15007       {
15008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15009       };
15010     }
15011   }
15012   jresult = (void *)result;
15013   return jresult;
15014 }
15015
15016
15017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15018   void * jresult ;
15019   Dali::Quaternion *arg1 = 0 ;
15020   Dali::Property::Value *result = 0 ;
15021
15022   arg1 = (Dali::Quaternion *)jarg1;
15023   if (!arg1) {
15024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15025     return 0;
15026   }
15027   {
15028     try {
15029       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15030     } catch (std::out_of_range& e) {
15031       {
15032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15033       };
15034     } catch (std::exception& e) {
15035       {
15036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (...) {
15039       {
15040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15041       };
15042     }
15043   }
15044   jresult = (void *)result;
15045   return jresult;
15046 }
15047
15048
15049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15050   void * jresult ;
15051   std::string *arg1 = 0 ;
15052   Dali::Property::Value *result = 0 ;
15053
15054   if (!jarg1) {
15055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15056     return 0;
15057   }
15058   std::string arg1_str(jarg1);
15059   arg1 = &arg1_str;
15060   {
15061     try {
15062       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15063     } catch (std::out_of_range& e) {
15064       {
15065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15066       };
15067     } catch (std::exception& e) {
15068       {
15069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15070       };
15071     } catch (...) {
15072       {
15073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15074       };
15075     }
15076   }
15077   jresult = (void *)result;
15078
15079   //argout typemap for const std::string&
15080
15081   return jresult;
15082 }
15083
15084
15085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15086   void * jresult ;
15087   Dali::Property::Array *arg1 = 0 ;
15088   Dali::Property::Value *result = 0 ;
15089
15090   arg1 = (Dali::Property::Array *)jarg1;
15091   if (!arg1) {
15092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15093     return 0;
15094   }
15095   {
15096     try {
15097       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15098     } catch (std::out_of_range& e) {
15099       {
15100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15101       };
15102     } catch (std::exception& e) {
15103       {
15104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15105       };
15106     } catch (...) {
15107       {
15108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15109       };
15110     }
15111   }
15112   jresult = (void *)result;
15113   return jresult;
15114 }
15115
15116
15117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15118   void * jresult ;
15119   Dali::Property::Map *arg1 = 0 ;
15120   Dali::Property::Value *result = 0 ;
15121
15122   arg1 = (Dali::Property::Map *)jarg1;
15123   if (!arg1) {
15124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15125     return 0;
15126   }
15127   {
15128     try {
15129       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15137       };
15138     } catch (...) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15141       };
15142     }
15143   }
15144   jresult = (void *)result;
15145   return jresult;
15146 }
15147
15148
15149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15150   void * jresult ;
15151   Dali::Property::Type arg1 ;
15152   Dali::Property::Value *result = 0 ;
15153
15154   arg1 = (Dali::Property::Type)jarg1;
15155   {
15156     try {
15157       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15158     } catch (std::out_of_range& e) {
15159       {
15160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15161       };
15162     } catch (std::exception& e) {
15163       {
15164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15165       };
15166     } catch (...) {
15167       {
15168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15169       };
15170     }
15171   }
15172   jresult = (void *)result;
15173   return jresult;
15174 }
15175
15176
15177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15178   void * jresult ;
15179   Dali::Property::Value *arg1 = 0 ;
15180   Dali::Property::Value *result = 0 ;
15181
15182   arg1 = (Dali::Property::Value *)jarg1;
15183   if (!arg1) {
15184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15185     return 0;
15186   }
15187   {
15188     try {
15189       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15190     } catch (std::out_of_range& e) {
15191       {
15192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (std::exception& e) {
15195       {
15196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (...) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15201       };
15202     }
15203   }
15204   jresult = (void *)result;
15205   return jresult;
15206 }
15207
15208
15209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15210   void * jresult ;
15211   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15212   Dali::Property::Value *arg2 = 0 ;
15213   Dali::Property::Value *result = 0 ;
15214
15215   arg1 = (Dali::Property::Value *)jarg1;
15216   arg2 = (Dali::Property::Value *)jarg2;
15217   if (!arg2) {
15218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15219     return 0;
15220   }
15221   {
15222     try {
15223       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15224     } catch (std::out_of_range& e) {
15225       {
15226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15227       };
15228     } catch (std::exception& e) {
15229       {
15230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15231       };
15232     } catch (...) {
15233       {
15234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15235       };
15236     }
15237   }
15238   jresult = (void *)result;
15239   return jresult;
15240 }
15241
15242
15243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15244   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15245
15246   arg1 = (Dali::Property::Value *)jarg1;
15247   {
15248     try {
15249       delete arg1;
15250     } catch (std::out_of_range& e) {
15251       {
15252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15253       };
15254     } catch (std::exception& e) {
15255       {
15256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15257       };
15258     } catch (...) {
15259       {
15260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15261       };
15262     }
15263   }
15264 }
15265
15266
15267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15268   int jresult ;
15269   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15270   Dali::Property::Type result;
15271
15272   arg1 = (Dali::Property::Value *)jarg1;
15273   {
15274     try {
15275       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15276     } catch (std::out_of_range& e) {
15277       {
15278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15279       };
15280     } catch (std::exception& e) {
15281       {
15282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15283       };
15284     } catch (...) {
15285       {
15286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15287       };
15288     }
15289   }
15290   jresult = (int)result;
15291   return jresult;
15292 }
15293
15294
15295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15296   unsigned int jresult ;
15297   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15298   bool *arg2 = 0 ;
15299   bool result;
15300
15301   arg1 = (Dali::Property::Value *)jarg1;
15302   arg2 = (bool *)jarg2;
15303   {
15304     try {
15305       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15306     } catch (std::out_of_range& e) {
15307       {
15308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (std::exception& e) {
15311       {
15312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15313       };
15314     } catch (...) {
15315       {
15316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15317       };
15318     }
15319   }
15320   jresult = result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15326   unsigned int jresult ;
15327   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15328   float *arg2 = 0 ;
15329   bool result;
15330
15331   arg1 = (Dali::Property::Value *)jarg1;
15332   arg2 = (float *)jarg2;
15333   {
15334     try {
15335       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (...) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15347       };
15348     }
15349   }
15350   jresult = result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15356   unsigned int jresult ;
15357   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15358   int *arg2 = 0 ;
15359   bool result;
15360
15361   arg1 = (Dali::Property::Value *)jarg1;
15362   arg2 = (int *)jarg2;
15363   {
15364     try {
15365       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15366     } catch (std::out_of_range& e) {
15367       {
15368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15369       };
15370     } catch (std::exception& e) {
15371       {
15372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15373       };
15374     } catch (...) {
15375       {
15376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15377       };
15378     }
15379   }
15380   jresult = result;
15381   return jresult;
15382 }
15383
15384
15385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15386   unsigned int jresult ;
15387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15388   Dali::Rect< int > *arg2 = 0 ;
15389   bool result;
15390
15391   arg1 = (Dali::Property::Value *)jarg1;
15392   arg2 = (Dali::Rect< int > *)jarg2;
15393   if (!arg2) {
15394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15395     return 0;
15396   }
15397   {
15398     try {
15399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15400     } catch (std::out_of_range& e) {
15401       {
15402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15403       };
15404     } catch (std::exception& e) {
15405       {
15406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15407       };
15408     } catch (...) {
15409       {
15410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15411       };
15412     }
15413   }
15414   jresult = result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15420   unsigned int jresult ;
15421   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15422   Dali::Vector2 *arg2 = 0 ;
15423   bool result;
15424
15425   arg1 = (Dali::Property::Value *)jarg1;
15426   arg2 = (Dali::Vector2 *)jarg2;
15427   if (!arg2) {
15428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15429     return 0;
15430   }
15431   {
15432     try {
15433       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15434     } catch (std::out_of_range& e) {
15435       {
15436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15437       };
15438     } catch (std::exception& e) {
15439       {
15440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (...) {
15443       {
15444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15445       };
15446     }
15447   }
15448   jresult = result;
15449   return jresult;
15450 }
15451
15452
15453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15454   unsigned int jresult ;
15455   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15456   Dali::Vector3 *arg2 = 0 ;
15457   bool result;
15458
15459   arg1 = (Dali::Property::Value *)jarg1;
15460   arg2 = (Dali::Vector3 *)jarg2;
15461   if (!arg2) {
15462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15463     return 0;
15464   }
15465   {
15466     try {
15467       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15468     } catch (std::out_of_range& e) {
15469       {
15470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15471       };
15472     } catch (std::exception& e) {
15473       {
15474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (...) {
15477       {
15478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15479       };
15480     }
15481   }
15482   jresult = result;
15483   return jresult;
15484 }
15485
15486
15487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15488   unsigned int jresult ;
15489   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15490   Dali::Vector4 *arg2 = 0 ;
15491   bool result;
15492
15493   arg1 = (Dali::Property::Value *)jarg1;
15494   arg2 = (Dali::Vector4 *)jarg2;
15495   if (!arg2) {
15496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15497     return 0;
15498   }
15499   {
15500     try {
15501       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15502     } catch (std::out_of_range& e) {
15503       {
15504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (std::exception& e) {
15507       {
15508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15509       };
15510     } catch (...) {
15511       {
15512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15513       };
15514     }
15515   }
15516   jresult = result;
15517   return jresult;
15518 }
15519
15520
15521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15522   unsigned int jresult ;
15523   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15524   Dali::Matrix3 *arg2 = 0 ;
15525   bool result;
15526
15527   arg1 = (Dali::Property::Value *)jarg1;
15528   arg2 = (Dali::Matrix3 *)jarg2;
15529   if (!arg2) {
15530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15531     return 0;
15532   }
15533   {
15534     try {
15535       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15536     } catch (std::out_of_range& e) {
15537       {
15538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15539       };
15540     } catch (std::exception& e) {
15541       {
15542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15543       };
15544     } catch (...) {
15545       {
15546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15547       };
15548     }
15549   }
15550   jresult = result;
15551   return jresult;
15552 }
15553
15554
15555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15556   unsigned int jresult ;
15557   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15558   Dali::Matrix *arg2 = 0 ;
15559   bool result;
15560
15561   arg1 = (Dali::Property::Value *)jarg1;
15562   arg2 = (Dali::Matrix *)jarg2;
15563   if (!arg2) {
15564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15565     return 0;
15566   }
15567   {
15568     try {
15569       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15570     } catch (std::out_of_range& e) {
15571       {
15572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (std::exception& e) {
15575       {
15576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15577       };
15578     } catch (...) {
15579       {
15580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15581       };
15582     }
15583   }
15584   jresult = result;
15585   return jresult;
15586 }
15587
15588
15589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15590   unsigned int jresult ;
15591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15592   Dali::AngleAxis *arg2 = 0 ;
15593   bool result;
15594
15595   arg1 = (Dali::Property::Value *)jarg1;
15596   arg2 = (Dali::AngleAxis *)jarg2;
15597   if (!arg2) {
15598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15599     return 0;
15600   }
15601   {
15602     try {
15603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15604     } catch (std::out_of_range& e) {
15605       {
15606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (std::exception& e) {
15609       {
15610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (...) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15615       };
15616     }
15617   }
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15626   Dali::Quaternion *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Value *)jarg1;
15630   arg2 = (Dali::Quaternion *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (...) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15649       };
15650     }
15651   }
15652   jresult = result;
15653   return jresult;
15654 }
15655
15656
15657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15658   unsigned int jresult ;
15659   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15660   std::string *arg2 = 0 ;
15661   bool result;
15662
15663   arg1 = (Dali::Property::Value *)jarg1;
15664
15665   //typemap in
15666   std::string temp;
15667   arg2 = &temp;
15668
15669   {
15670     try {
15671       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15683       };
15684     }
15685   }
15686   jresult = result;
15687
15688   //Typemap argout in c++ file.
15689   //This will convert c++ string to c# string
15690   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15691
15692   return jresult;
15693 }
15694
15695
15696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15697   unsigned int jresult ;
15698   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15699   Dali::Property::Array *arg2 = 0 ;
15700   bool result;
15701
15702   arg1 = (Dali::Property::Value *)jarg1;
15703   arg2 = (Dali::Property::Array *)jarg2;
15704   if (!arg2) {
15705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15706     return 0;
15707   }
15708   {
15709     try {
15710       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15711     } catch (std::out_of_range& e) {
15712       {
15713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15714       };
15715     } catch (std::exception& e) {
15716       {
15717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15718       };
15719     } catch (...) {
15720       {
15721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15722       };
15723     }
15724   }
15725   jresult = result;
15726   return jresult;
15727 }
15728
15729
15730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15731   unsigned int jresult ;
15732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15733   Dali::Property::Map *arg2 = 0 ;
15734   bool result;
15735
15736   arg1 = (Dali::Property::Value *)jarg1;
15737   arg2 = (Dali::Property::Map *)jarg2;
15738   if (!arg2) {
15739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15740     return 0;
15741   }
15742   {
15743     try {
15744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15745     } catch (std::out_of_range& e) {
15746       {
15747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15748       };
15749     } catch (std::exception& e) {
15750       {
15751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15756       };
15757     }
15758   }
15759   jresult = result;
15760   return jresult;
15761 }
15762
15763
15764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15765   void * jresult ;
15766   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15767   Dali::Property::Array *result = 0 ;
15768
15769   arg1 = (Dali::Property::Value *)jarg1;
15770   {
15771     try {
15772       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15773     } catch (std::out_of_range& e) {
15774       {
15775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15776       };
15777     } catch (std::exception& e) {
15778       {
15779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15780       };
15781     } catch (...) {
15782       {
15783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15784       };
15785     }
15786   }
15787   jresult = (void *)result;
15788   return jresult;
15789 }
15790
15791
15792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15793   void * jresult ;
15794   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15795   Dali::Property::Map *result = 0 ;
15796
15797   arg1 = (Dali::Property::Value *)jarg1;
15798   {
15799     try {
15800       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15801     } catch (std::out_of_range& e) {
15802       {
15803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15804       };
15805     } catch (std::exception& e) {
15806       {
15807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15808       };
15809     } catch (...) {
15810       {
15811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15812       };
15813     }
15814   }
15815   jresult = (void *)result;
15816   return jresult;
15817 }
15818
15819
15820 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15821   char * jresult ;
15822   Dali::Property::Type arg1 ;
15823   char *result = 0 ;
15824
15825   arg1 = (Dali::Property::Type)jarg1;
15826   {
15827     try {
15828       result = (char *)Dali::PropertyTypes::GetName(arg1);
15829     } catch (std::out_of_range& e) {
15830       {
15831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15832       };
15833     } catch (std::exception& e) {
15834       {
15835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15836       };
15837     } catch (...) {
15838       {
15839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15840       };
15841     }
15842   }
15843   jresult = SWIG_csharp_string_callback((const char *)result);
15844   return jresult;
15845 }
15846
15847
15848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15849   unsigned int jresult ;
15850   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15851   std::string *arg2 = 0 ;
15852   Dali::Property::Map *arg3 = 0 ;
15853   bool result;
15854
15855   arg1 = (Dali::BaseObject *)jarg1;
15856   if (!jarg2) {
15857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15858     return 0;
15859   }
15860   std::string arg2_str(jarg2);
15861   arg2 = &arg2_str;
15862   arg3 = (Dali::Property::Map *)jarg3;
15863   if (!arg3) {
15864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15865     return 0;
15866   }
15867   {
15868     try {
15869       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15870     } catch (std::out_of_range& e) {
15871       {
15872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15873       };
15874     } catch (std::exception& e) {
15875       {
15876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15877       };
15878     } catch (...) {
15879       {
15880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15881       };
15882     }
15883   }
15884   jresult = result;
15885
15886   //argout typemap for const std::string&
15887
15888   return jresult;
15889 }
15890
15891
15892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15893   char * jresult ;
15894   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15895   std::string *result = 0 ;
15896
15897   arg1 = (Dali::BaseObject *)jarg1;
15898   {
15899     try {
15900       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15901     } catch (std::out_of_range& e) {
15902       {
15903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15904       };
15905     } catch (std::exception& e) {
15906       {
15907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15908       };
15909     } catch (...) {
15910       {
15911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15912       };
15913     }
15914   }
15915   jresult = SWIG_csharp_string_callback(result->c_str());
15916   return jresult;
15917 }
15918
15919
15920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15921   unsigned int jresult ;
15922   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15923   Dali::TypeInfo *arg2 = 0 ;
15924   bool result;
15925
15926   arg1 = (Dali::BaseObject *)jarg1;
15927   arg2 = (Dali::TypeInfo *)jarg2;
15928   if (!arg2) {
15929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15930     return 0;
15931   }
15932   {
15933     try {
15934       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15935     } catch (std::out_of_range& e) {
15936       {
15937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15938       };
15939     } catch (std::exception& e) {
15940       {
15941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15942       };
15943     } catch (...) {
15944       {
15945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15946       };
15947     }
15948   }
15949   jresult = result;
15950   return jresult;
15951 }
15952
15953
15954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15955   unsigned int jresult ;
15956   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15957   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15958   std::string *arg3 = 0 ;
15959   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15960   bool result;
15961
15962   arg1 = (Dali::BaseObject *)jarg1;
15963   arg2 = (ConnectionTrackerInterface *)jarg2;
15964   if (!jarg3) {
15965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15966     return 0;
15967   }
15968   std::string arg3_str(jarg3);
15969   arg3 = &arg3_str;
15970   arg4 = (FunctorDelegate *)jarg4;
15971   {
15972     try {
15973       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15974     } catch (std::out_of_range& e) {
15975       {
15976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15977       };
15978     } catch (std::exception& e) {
15979       {
15980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15981       };
15982     } catch (...) {
15983       {
15984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15985       };
15986     }
15987   }
15988   jresult = result;
15989
15990   //argout typemap for const std::string&
15991
15992   return jresult;
15993 }
15994
15995
15996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
15997   void * jresult ;
15998   Dali::BaseHandle *arg1 = 0 ;
15999   Dali::BaseObject *result = 0 ;
16000
16001   arg1 = (Dali::BaseHandle *)jarg1;
16002   if (!arg1) {
16003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16004     return 0;
16005   }
16006   {
16007     try {
16008       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16009     } catch (std::out_of_range& e) {
16010       {
16011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16012       };
16013     } catch (std::exception& e) {
16014       {
16015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16016       };
16017     } catch (...) {
16018       {
16019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16020       };
16021     }
16022   }
16023   jresult = (void *)result;
16024   return jresult;
16025 }
16026
16027
16028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16029   void * jresult ;
16030   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16031   Dali::BaseHandle *result = 0 ;
16032
16033   arg1 = (Dali::BaseObject *)jarg1;
16034   {
16035     try {
16036       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16037     } catch (std::out_of_range& e) {
16038       {
16039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16040       };
16041     } catch (std::exception& e) {
16042       {
16043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16044       };
16045     } catch (...) {
16046       {
16047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16048       };
16049     }
16050   }
16051   jresult = (void *)result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16057   void * jresult ;
16058   Dali::BaseHandle *result = 0 ;
16059
16060   {
16061     try {
16062       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16063     } catch (std::out_of_range& e) {
16064       {
16065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16066       };
16067     } catch (std::exception& e) {
16068       {
16069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16070       };
16071     } catch (...) {
16072       {
16073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16074       };
16075     }
16076   }
16077   jresult = (void *)result;
16078   return jresult;
16079 }
16080
16081
16082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16083   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16084
16085   arg1 = (Dali::BaseHandle *)jarg1;
16086   {
16087     try {
16088       delete arg1;
16089     } catch (std::out_of_range& e) {
16090       {
16091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16092       };
16093     } catch (std::exception& e) {
16094       {
16095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16096       };
16097     } catch (...) {
16098       {
16099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16100       };
16101     }
16102   }
16103 }
16104
16105
16106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16107   void * jresult ;
16108   Dali::BaseHandle *arg1 = 0 ;
16109   Dali::BaseHandle *result = 0 ;
16110
16111   arg1 = (Dali::BaseHandle *)jarg1;
16112   if (!arg1) {
16113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16114     return 0;
16115   }
16116   {
16117     try {
16118       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16119     } catch (std::out_of_range& e) {
16120       {
16121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16122       };
16123     } catch (std::exception& e) {
16124       {
16125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16126       };
16127     } catch (...) {
16128       {
16129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16130       };
16131     }
16132   }
16133   jresult = (void *)result;
16134   return jresult;
16135 }
16136
16137
16138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16139   void * jresult ;
16140   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16141   Dali::BaseHandle *arg2 = 0 ;
16142   Dali::BaseHandle *result = 0 ;
16143
16144   arg1 = (Dali::BaseHandle *)jarg1;
16145   arg2 = (Dali::BaseHandle *)jarg2;
16146   if (!arg2) {
16147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16148     return 0;
16149   }
16150   {
16151     try {
16152       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16153     } catch (std::out_of_range& e) {
16154       {
16155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16156       };
16157     } catch (std::exception& e) {
16158       {
16159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16160       };
16161     } catch (...) {
16162       {
16163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16164       };
16165     }
16166   }
16167   jresult = (void *)result;
16168   return jresult;
16169 }
16170
16171
16172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16173   unsigned int jresult ;
16174   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16175   std::string *arg2 = 0 ;
16176   Dali::Property::Map *arg3 = 0 ;
16177   bool result;
16178
16179   arg1 = (Dali::BaseHandle *)jarg1;
16180   if (!jarg2) {
16181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16182     return 0;
16183   }
16184   std::string arg2_str(jarg2);
16185   arg2 = &arg2_str;
16186   arg3 = (Dali::Property::Map *)jarg3;
16187   if (!arg3) {
16188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16189     return 0;
16190   }
16191   {
16192     try {
16193       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16194     } catch (std::out_of_range& e) {
16195       {
16196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16197       };
16198     } catch (std::exception& e) {
16199       {
16200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (...) {
16203       {
16204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16205       };
16206     }
16207   }
16208   jresult = result;
16209
16210   //argout typemap for const std::string&
16211
16212   return jresult;
16213 }
16214
16215
16216 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16217   char * jresult ;
16218   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16219   std::string *result = 0 ;
16220
16221   arg1 = (Dali::BaseHandle *)jarg1;
16222   {
16223     try {
16224       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16225     } catch (std::out_of_range& e) {
16226       {
16227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16228       };
16229     } catch (std::exception& e) {
16230       {
16231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16232       };
16233     } catch (...) {
16234       {
16235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16236       };
16237     }
16238   }
16239   jresult = SWIG_csharp_string_callback(result->c_str());
16240   return jresult;
16241 }
16242
16243
16244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16245   unsigned int jresult ;
16246   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16247   Dali::TypeInfo *arg2 = 0 ;
16248   bool result;
16249
16250   arg1 = (Dali::BaseHandle *)jarg1;
16251   arg2 = (Dali::TypeInfo *)jarg2;
16252   if (!arg2) {
16253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16254     return 0;
16255   }
16256   {
16257     try {
16258       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16259     } catch (std::out_of_range& e) {
16260       {
16261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16262       };
16263     } catch (std::exception& e) {
16264       {
16265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16266       };
16267     } catch (...) {
16268       {
16269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16270       };
16271     }
16272   }
16273   jresult = result;
16274   return jresult;
16275 }
16276
16277
16278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16279   void * jresult ;
16280   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16281   Dali::BaseObject *result = 0 ;
16282
16283   arg1 = (Dali::BaseHandle *)jarg1;
16284   {
16285     try {
16286       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16287     } catch (std::out_of_range& e) {
16288       {
16289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16290       };
16291     } catch (std::exception& e) {
16292       {
16293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16294       };
16295     } catch (...) {
16296       {
16297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16298       };
16299     }
16300   }
16301   jresult = (void *)result;
16302   return jresult;
16303 }
16304
16305
16306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16307   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16308
16309   arg1 = (Dali::BaseHandle *)jarg1;
16310   {
16311     try {
16312       (arg1)->Reset();
16313     } catch (std::out_of_range& e) {
16314       {
16315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16316       };
16317     } catch (std::exception& e) {
16318       {
16319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16320       };
16321     } catch (...) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16324       };
16325     }
16326   }
16327 }
16328
16329
16330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16331   unsigned int jresult ;
16332   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16333   Dali::BaseHandle *arg2 = 0 ;
16334   bool result;
16335
16336   arg1 = (Dali::BaseHandle *)jarg1;
16337   arg2 = (Dali::BaseHandle *)jarg2;
16338   if (!arg2) {
16339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16340     return 0;
16341   }
16342   {
16343     try {
16344       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16345     } catch (std::out_of_range& e) {
16346       {
16347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16348       };
16349     } catch (std::exception& e) {
16350       {
16351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16352       };
16353     } catch (...) {
16354       {
16355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16356       };
16357     }
16358   }
16359   jresult = result;
16360   return jresult;
16361 }
16362
16363
16364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16365   unsigned int jresult ;
16366   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16367   Dali::BaseHandle *arg2 = 0 ;
16368   bool result;
16369
16370   arg1 = (Dali::BaseHandle *)jarg1;
16371   arg2 = (Dali::BaseHandle *)jarg2;
16372   if (!arg2) {
16373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16374     return 0;
16375   }
16376   {
16377     try {
16378       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16379     } catch (std::out_of_range& e) {
16380       {
16381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16382       };
16383     } catch (std::exception& e) {
16384       {
16385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16386       };
16387     } catch (...) {
16388       {
16389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16390       };
16391     }
16392   }
16393   jresult = result;
16394   return jresult;
16395 }
16396
16397
16398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16399   void * jresult ;
16400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16401   Dali::RefObject *result = 0 ;
16402
16403   arg1 = (Dali::BaseHandle *)jarg1;
16404   {
16405     try {
16406       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16407     } catch (std::out_of_range& e) {
16408       {
16409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16410       };
16411     } catch (std::exception& e) {
16412       {
16413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16414       };
16415     } catch (...) {
16416       {
16417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16418       };
16419     }
16420   }
16421   jresult = (void *)result;
16422   return jresult;
16423 }
16424
16425
16426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16427   unsigned int jresult ;
16428   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16429   bool result;
16430
16431   arg1 = (Dali::BaseHandle *)jarg1;
16432   {
16433     try {
16434       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16435     } catch (std::out_of_range& e) {
16436       {
16437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16438       };
16439     } catch (std::exception& e) {
16440       {
16441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16442       };
16443     } catch (...) {
16444       {
16445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16446       };
16447     }
16448   }
16449   jresult = result;
16450   return jresult;
16451 }
16452
16453
16454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16455   unsigned int jresult ;
16456   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16457   Dali::BaseHandle *arg2 = 0 ;
16458   bool result;
16459
16460   arg1 = (Dali::BaseHandle *)jarg1;
16461   arg2 = (Dali::BaseHandle *)jarg2;
16462   if (!arg2) {
16463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16464     return 0;
16465   }
16466   {
16467     try {
16468       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16469     } catch (std::out_of_range& e) {
16470       {
16471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16472       };
16473     } catch (std::exception& e) {
16474       {
16475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16476       };
16477     } catch (...) {
16478       {
16479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16480       };
16481     }
16482   }
16483   jresult = result;
16484   return jresult;
16485 }
16486
16487
16488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16489   unsigned int jresult ;
16490   Dali::BaseHandle *arg1 = 0 ;
16491   Dali::BaseHandle *arg2 = 0 ;
16492   bool result;
16493
16494   arg1 = (Dali::BaseHandle *)jarg1;
16495   if (!arg1) {
16496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16497     return 0;
16498   }
16499   arg2 = (Dali::BaseHandle *)jarg2;
16500   if (!arg2) {
16501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16502     return 0;
16503   }
16504   {
16505     try {
16506       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16507     } catch (std::out_of_range& e) {
16508       {
16509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16510       };
16511     } catch (std::exception& e) {
16512       {
16513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16514       };
16515     } catch (...) {
16516       {
16517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16518       };
16519     }
16520   }
16521   jresult = result;
16522   return jresult;
16523 }
16524
16525
16526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16527   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16528
16529   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16530   {
16531     try {
16532       delete arg1;
16533     } catch (std::out_of_range& e) {
16534       {
16535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16536       };
16537     } catch (std::exception& e) {
16538       {
16539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16540       };
16541     } catch (...) {
16542       {
16543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16544       };
16545     }
16546   }
16547 }
16548
16549
16550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16551   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16552   SlotObserver *arg2 = (SlotObserver *) 0 ;
16553   CallbackBase *arg3 = (CallbackBase *) 0 ;
16554
16555   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16556   arg2 = (SlotObserver *)jarg2;
16557   arg3 = (CallbackBase *)jarg3;
16558   {
16559     try {
16560       (arg1)->SignalConnected(arg2,arg3);
16561     } catch (std::out_of_range& e) {
16562       {
16563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16564       };
16565     } catch (std::exception& e) {
16566       {
16567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16568       };
16569     } catch (...) {
16570       {
16571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16572       };
16573     }
16574   }
16575 }
16576
16577
16578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16579   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16580
16581   arg1 = (Dali::SignalObserver *)jarg1;
16582   {
16583     try {
16584       delete arg1;
16585     } catch (std::out_of_range& e) {
16586       {
16587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16588       };
16589     } catch (std::exception& e) {
16590       {
16591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16596       };
16597     }
16598   }
16599 }
16600
16601
16602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16603   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16604   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16605   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16606
16607   arg1 = (Dali::SignalObserver *)jarg1;
16608   arg2 = (Dali::SlotObserver *)jarg2;
16609   arg3 = (Dali::CallbackBase *)jarg3;
16610   {
16611     try {
16612       (arg1)->SignalDisconnected(arg2,arg3);
16613     } catch (std::out_of_range& e) {
16614       {
16615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16616       };
16617     } catch (std::exception& e) {
16618       {
16619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16620       };
16621     } catch (...) {
16622       {
16623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16624       };
16625     }
16626   }
16627 }
16628
16629
16630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16631   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16632
16633   arg1 = (Dali::SlotObserver *)jarg1;
16634   {
16635     try {
16636       delete arg1;
16637     } catch (std::out_of_range& e) {
16638       {
16639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16640       };
16641     } catch (std::exception& e) {
16642       {
16643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16644       };
16645     } catch (...) {
16646       {
16647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16648       };
16649     }
16650   }
16651 }
16652
16653
16654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16655   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16656   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16657
16658   arg1 = (Dali::SlotObserver *)jarg1;
16659   arg2 = (Dali::CallbackBase *)jarg2;
16660   {
16661     try {
16662       (arg1)->SlotDisconnected(arg2);
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (...) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16674       };
16675     }
16676   }
16677 }
16678
16679
16680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16681   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16682
16683   arg1 = (Dali::ConnectionTracker *)jarg1;
16684   {
16685     try {
16686       delete arg1;
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16694       };
16695     } catch (...) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16698       };
16699     }
16700   }
16701 }
16702
16703
16704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16705   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16706
16707   arg1 = (Dali::ConnectionTracker *)jarg1;
16708   {
16709     try {
16710       (arg1)->DisconnectAll();
16711     } catch (std::out_of_range& e) {
16712       {
16713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16714       };
16715     } catch (std::exception& e) {
16716       {
16717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16718       };
16719     } catch (...) {
16720       {
16721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16722       };
16723     }
16724   }
16725 }
16726
16727
16728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16729   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16730   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16731   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16732
16733   arg1 = (Dali::ConnectionTracker *)jarg1;
16734   arg2 = (Dali::SlotObserver *)jarg2;
16735   arg3 = (Dali::CallbackBase *)jarg3;
16736   {
16737     try {
16738       (arg1)->SignalConnected(arg2,arg3);
16739     } catch (std::out_of_range& e) {
16740       {
16741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16742       };
16743     } catch (std::exception& e) {
16744       {
16745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16746       };
16747     } catch (...) {
16748       {
16749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16750       };
16751     }
16752   }
16753 }
16754
16755
16756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16757   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16758   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16759   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16760
16761   arg1 = (Dali::ConnectionTracker *)jarg1;
16762   arg2 = (Dali::SlotObserver *)jarg2;
16763   arg3 = (Dali::CallbackBase *)jarg3;
16764   {
16765     try {
16766       (arg1)->SignalDisconnected(arg2,arg3);
16767     } catch (std::out_of_range& e) {
16768       {
16769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16770       };
16771     } catch (std::exception& e) {
16772       {
16773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16774       };
16775     } catch (...) {
16776       {
16777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16778       };
16779     }
16780   }
16781 }
16782
16783
16784 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16785   unsigned long jresult ;
16786   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16787   std::size_t result;
16788
16789   arg1 = (Dali::ConnectionTracker *)jarg1;
16790   {
16791     try {
16792       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16793     } catch (std::out_of_range& e) {
16794       {
16795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16796       };
16797     } catch (std::exception& e) {
16798       {
16799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16800       };
16801     } catch (...) {
16802       {
16803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16804       };
16805     }
16806   }
16807   jresult = (unsigned long)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16813   void * jresult ;
16814   Dali::ObjectRegistry *result = 0 ;
16815
16816   {
16817     try {
16818       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16819     } catch (std::out_of_range& e) {
16820       {
16821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16822       };
16823     } catch (std::exception& e) {
16824       {
16825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16826       };
16827     } catch (...) {
16828       {
16829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16830       };
16831     }
16832   }
16833   jresult = (void *)result;
16834   return jresult;
16835 }
16836
16837
16838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16839   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16840
16841   arg1 = (Dali::ObjectRegistry *)jarg1;
16842   {
16843     try {
16844       delete arg1;
16845     } catch (std::out_of_range& e) {
16846       {
16847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16848       };
16849     } catch (std::exception& e) {
16850       {
16851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16852       };
16853     } catch (...) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16856       };
16857     }
16858   }
16859 }
16860
16861
16862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16863   void * jresult ;
16864   Dali::ObjectRegistry *arg1 = 0 ;
16865   Dali::ObjectRegistry *result = 0 ;
16866
16867   arg1 = (Dali::ObjectRegistry *)jarg1;
16868   if (!arg1) {
16869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16870     return 0;
16871   }
16872   {
16873     try {
16874       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16875     } catch (std::out_of_range& e) {
16876       {
16877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16878       };
16879     } catch (std::exception& e) {
16880       {
16881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16882       };
16883     } catch (...) {
16884       {
16885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16886       };
16887     }
16888   }
16889   jresult = (void *)result;
16890   return jresult;
16891 }
16892
16893
16894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16895   void * jresult ;
16896   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16897   Dali::ObjectRegistry *arg2 = 0 ;
16898   Dali::ObjectRegistry *result = 0 ;
16899
16900   arg1 = (Dali::ObjectRegistry *)jarg1;
16901   arg2 = (Dali::ObjectRegistry *)jarg2;
16902   if (!arg2) {
16903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16904     return 0;
16905   }
16906   {
16907     try {
16908       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16909     } catch (std::out_of_range& e) {
16910       {
16911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16912       };
16913     } catch (std::exception& e) {
16914       {
16915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16916       };
16917     } catch (...) {
16918       {
16919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16920       };
16921     }
16922   }
16923   jresult = (void *)result;
16924   return jresult;
16925 }
16926
16927
16928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16929   void * jresult ;
16930   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16931   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16932
16933   arg1 = (Dali::ObjectRegistry *)jarg1;
16934   {
16935     try {
16936       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16937     } catch (std::out_of_range& e) {
16938       {
16939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16940       };
16941     } catch (std::exception& e) {
16942       {
16943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16944       };
16945     } catch (...) {
16946       {
16947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16948       };
16949     }
16950   }
16951   jresult = (void *)result;
16952   return jresult;
16953 }
16954
16955
16956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16957   void * jresult ;
16958   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16959   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16960
16961   arg1 = (Dali::ObjectRegistry *)jarg1;
16962   {
16963     try {
16964       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16965     } catch (std::out_of_range& e) {
16966       {
16967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16968       };
16969     } catch (std::exception& e) {
16970       {
16971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16972       };
16973     } catch (...) {
16974       {
16975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16976       };
16977     }
16978   }
16979   jresult = (void *)result;
16980   return jresult;
16981 }
16982
16983
16984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
16985   void * jresult ;
16986   Dali::PropertyCondition *result = 0 ;
16987
16988   {
16989     try {
16990       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
16991     } catch (std::out_of_range& e) {
16992       {
16993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (std::exception& e) {
16996       {
16997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (...) {
17000       {
17001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17002       };
17003     }
17004   }
17005   jresult = (void *)result;
17006   return jresult;
17007 }
17008
17009
17010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17011   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17012
17013   arg1 = (Dali::PropertyCondition *)jarg1;
17014   {
17015     try {
17016       delete arg1;
17017     } catch (std::out_of_range& e) {
17018       {
17019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17020       };
17021     } catch (std::exception& e) {
17022       {
17023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17024       };
17025     } catch (...) {
17026       {
17027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17028       };
17029     }
17030   }
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17035   void * jresult ;
17036   Dali::PropertyCondition *arg1 = 0 ;
17037   Dali::PropertyCondition *result = 0 ;
17038
17039   arg1 = (Dali::PropertyCondition *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (...) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17058       };
17059     }
17060   }
17061   jresult = (void *)result;
17062   return jresult;
17063 }
17064
17065
17066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17067   void * jresult ;
17068   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17069   Dali::PropertyCondition *arg2 = 0 ;
17070   Dali::PropertyCondition *result = 0 ;
17071
17072   arg1 = (Dali::PropertyCondition *)jarg1;
17073   arg2 = (Dali::PropertyCondition *)jarg2;
17074   if (!arg2) {
17075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17076     return 0;
17077   }
17078   {
17079     try {
17080       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17081     } catch (std::out_of_range& e) {
17082       {
17083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17084       };
17085     } catch (std::exception& e) {
17086       {
17087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (...) {
17090       {
17091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17092       };
17093     }
17094   }
17095   jresult = (void *)result;
17096   return jresult;
17097 }
17098
17099
17100 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17101   unsigned long jresult ;
17102   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17103   std::size_t result;
17104
17105   arg1 = (Dali::PropertyCondition *)jarg1;
17106   {
17107     try {
17108       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17109     } catch (std::out_of_range& e) {
17110       {
17111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17112       };
17113     } catch (std::exception& e) {
17114       {
17115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17116       };
17117     } catch (...) {
17118       {
17119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17120       };
17121     }
17122   }
17123   jresult = (unsigned long)result;
17124   return jresult;
17125 }
17126
17127
17128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17129   float jresult ;
17130   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17131   std::size_t arg2 ;
17132   float result;
17133
17134   arg1 = (Dali::PropertyCondition *)jarg1;
17135   arg2 = (std::size_t)jarg2;
17136   {
17137     try {
17138       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17139     } catch (std::out_of_range& e) {
17140       {
17141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17142       };
17143     } catch (std::exception& e) {
17144       {
17145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17146       };
17147     } catch (...) {
17148       {
17149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17150       };
17151     }
17152   }
17153   jresult = result;
17154   return jresult;
17155 }
17156
17157
17158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17159   void * jresult ;
17160   float arg1 ;
17161   Dali::PropertyCondition result;
17162
17163   arg1 = (float)jarg1;
17164   {
17165     try {
17166       result = Dali::LessThanCondition(arg1);
17167     } catch (std::out_of_range& e) {
17168       {
17169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17170       };
17171     } catch (std::exception& e) {
17172       {
17173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17174       };
17175     } catch (...) {
17176       {
17177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17178       };
17179     }
17180   }
17181   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17187   void * jresult ;
17188   float arg1 ;
17189   Dali::PropertyCondition result;
17190
17191   arg1 = (float)jarg1;
17192   {
17193     try {
17194       result = Dali::GreaterThanCondition(arg1);
17195     } catch (std::out_of_range& e) {
17196       {
17197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17198       };
17199     } catch (std::exception& e) {
17200       {
17201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (...) {
17204       {
17205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17206       };
17207     }
17208   }
17209   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17215   void * jresult ;
17216   float arg1 ;
17217   float arg2 ;
17218   Dali::PropertyCondition result;
17219
17220   arg1 = (float)jarg1;
17221   arg2 = (float)jarg2;
17222   {
17223     try {
17224       result = Dali::InsideCondition(arg1,arg2);
17225     } catch (std::out_of_range& e) {
17226       {
17227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (std::exception& e) {
17230       {
17231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (...) {
17234       {
17235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17236       };
17237     }
17238   }
17239   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17240   return jresult;
17241 }
17242
17243
17244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17245   void * jresult ;
17246   float arg1 ;
17247   float arg2 ;
17248   Dali::PropertyCondition result;
17249
17250   arg1 = (float)jarg1;
17251   arg2 = (float)jarg2;
17252   {
17253     try {
17254       result = Dali::OutsideCondition(arg1,arg2);
17255     } catch (std::out_of_range& e) {
17256       {
17257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17258       };
17259     } catch (std::exception& e) {
17260       {
17261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17262       };
17263     } catch (...) {
17264       {
17265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17266       };
17267     }
17268   }
17269   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17270   return jresult;
17271 }
17272
17273
17274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17275   void * jresult ;
17276   float arg1 ;
17277   float arg2 ;
17278   Dali::PropertyCondition result;
17279
17280   arg1 = (float)jarg1;
17281   arg2 = (float)jarg2;
17282   {
17283     try {
17284       result = Dali::StepCondition(arg1,arg2);
17285     } catch (std::out_of_range& e) {
17286       {
17287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17288       };
17289     } catch (std::exception& e) {
17290       {
17291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17292       };
17293     } catch (...) {
17294       {
17295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17296       };
17297     }
17298   }
17299   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17300   return jresult;
17301 }
17302
17303
17304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17305   void * jresult ;
17306   float arg1 ;
17307   Dali::PropertyCondition result;
17308
17309   arg1 = (float)jarg1;
17310   {
17311     try {
17312       result = Dali::StepCondition(arg1);
17313     } catch (std::out_of_range& e) {
17314       {
17315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17316       };
17317     } catch (std::exception& e) {
17318       {
17319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17320       };
17321     } catch (...) {
17322       {
17323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17324       };
17325     }
17326   }
17327   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17328   return jresult;
17329 }
17330
17331
17332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17333   void * jresult ;
17334   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17335   Dali::PropertyCondition result;
17336
17337   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17338   if (!arg1) {
17339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17340     return 0;
17341   }
17342   {
17343     try {
17344       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17345     } catch (std::out_of_range& e) {
17346       {
17347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17348       };
17349     } catch (std::exception& e) {
17350       {
17351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17352       };
17353     } catch (...) {
17354       {
17355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17356       };
17357     }
17358   }
17359   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17360   return jresult;
17361 }
17362
17363
17364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17365   void * jresult ;
17366   Dali::PropertyNotification *result = 0 ;
17367
17368   {
17369     try {
17370       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17371     } catch (std::out_of_range& e) {
17372       {
17373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (std::exception& e) {
17376       {
17377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17378       };
17379     } catch (...) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17382       };
17383     }
17384   }
17385   jresult = (void *)result;
17386   return jresult;
17387 }
17388
17389
17390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17391   void * jresult ;
17392   Dali::BaseHandle arg1 ;
17393   Dali::BaseHandle *argp1 ;
17394   Dali::PropertyNotification result;
17395
17396   argp1 = (Dali::BaseHandle *)jarg1;
17397   if (!argp1) {
17398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17399     return 0;
17400   }
17401   arg1 = *argp1;
17402   {
17403     try {
17404       result = Dali::PropertyNotification::DownCast(arg1);
17405     } catch (std::out_of_range& e) {
17406       {
17407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17408       };
17409     } catch (std::exception& e) {
17410       {
17411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17412       };
17413     } catch (...) {
17414       {
17415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17416       };
17417     }
17418   }
17419   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17425   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17426
17427   arg1 = (Dali::PropertyNotification *)jarg1;
17428   {
17429     try {
17430       delete arg1;
17431     } catch (std::out_of_range& e) {
17432       {
17433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17434       };
17435     } catch (std::exception& e) {
17436       {
17437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17438       };
17439     } catch (...) {
17440       {
17441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17442       };
17443     }
17444   }
17445 }
17446
17447
17448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17449   void * jresult ;
17450   Dali::PropertyNotification *arg1 = 0 ;
17451   Dali::PropertyNotification *result = 0 ;
17452
17453   arg1 = (Dali::PropertyNotification *)jarg1;
17454   if (!arg1) {
17455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17456     return 0;
17457   }
17458   {
17459     try {
17460       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17461     } catch (std::out_of_range& e) {
17462       {
17463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17464       };
17465     } catch (std::exception& e) {
17466       {
17467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17468       };
17469     } catch (...) {
17470       {
17471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17472       };
17473     }
17474   }
17475   jresult = (void *)result;
17476   return jresult;
17477 }
17478
17479
17480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17481   void * jresult ;
17482   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17483   Dali::PropertyNotification *arg2 = 0 ;
17484   Dali::PropertyNotification *result = 0 ;
17485
17486   arg1 = (Dali::PropertyNotification *)jarg1;
17487   arg2 = (Dali::PropertyNotification *)jarg2;
17488   if (!arg2) {
17489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17490     return 0;
17491   }
17492   {
17493     try {
17494       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17495     } catch (std::out_of_range& e) {
17496       {
17497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17498       };
17499     } catch (std::exception& e) {
17500       {
17501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17502       };
17503     } catch (...) {
17504       {
17505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17506       };
17507     }
17508   }
17509   jresult = (void *)result;
17510   return jresult;
17511 }
17512
17513
17514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17515   void * jresult ;
17516   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17517   Dali::PropertyCondition result;
17518
17519   arg1 = (Dali::PropertyNotification *)jarg1;
17520   {
17521     try {
17522       result = (arg1)->GetCondition();
17523     } catch (std::out_of_range& e) {
17524       {
17525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17526       };
17527     } catch (std::exception& e) {
17528       {
17529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17530       };
17531     } catch (...) {
17532       {
17533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17534       };
17535     }
17536   }
17537   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17538   return jresult;
17539 }
17540
17541
17542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17543   void * jresult ;
17544   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17545   Dali::Handle result;
17546
17547   arg1 = (Dali::PropertyNotification *)jarg1;
17548   {
17549     try {
17550       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17551     } catch (std::out_of_range& e) {
17552       {
17553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17554       };
17555     } catch (std::exception& e) {
17556       {
17557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17558       };
17559     } catch (...) {
17560       {
17561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17562       };
17563     }
17564   }
17565   jresult = new Dali::Handle((const Dali::Handle &)result);
17566   return jresult;
17567 }
17568
17569
17570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17571   int jresult ;
17572   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17573   Dali::Property::Index result;
17574
17575   arg1 = (Dali::PropertyNotification *)jarg1;
17576   {
17577     try {
17578       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17579     } catch (std::out_of_range& e) {
17580       {
17581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17582       };
17583     } catch (std::exception& e) {
17584       {
17585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17586       };
17587     } catch (...) {
17588       {
17589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17590       };
17591     }
17592   }
17593   jresult = result;
17594   return jresult;
17595 }
17596
17597
17598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17599   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17600   Dali::PropertyNotification::NotifyMode arg2 ;
17601
17602   arg1 = (Dali::PropertyNotification *)jarg1;
17603   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17604   {
17605     try {
17606       (arg1)->SetNotifyMode(arg2);
17607     } catch (std::out_of_range& e) {
17608       {
17609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17610       };
17611     } catch (std::exception& e) {
17612       {
17613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17614       };
17615     } catch (...) {
17616       {
17617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17618       };
17619     }
17620   }
17621 }
17622
17623
17624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17625   int jresult ;
17626   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17627   Dali::PropertyNotification::NotifyMode result;
17628
17629   arg1 = (Dali::PropertyNotification *)jarg1;
17630   {
17631     try {
17632       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17633     } catch (std::out_of_range& e) {
17634       {
17635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17636       };
17637     } catch (std::exception& e) {
17638       {
17639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17640       };
17641     } catch (...) {
17642       {
17643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17644       };
17645     }
17646   }
17647   jresult = (int)result;
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17653   unsigned int jresult ;
17654   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17655   bool result;
17656
17657   arg1 = (Dali::PropertyNotification *)jarg1;
17658   {
17659     try {
17660       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (...) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17672       };
17673     }
17674   }
17675   jresult = result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17681   void * jresult ;
17682   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17683   Dali::PropertyNotifySignalType *result = 0 ;
17684
17685   arg1 = (Dali::PropertyNotification *)jarg1;
17686   {
17687     try {
17688       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17689     } catch (std::out_of_range& e) {
17690       {
17691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17692       };
17693     } catch (std::exception& e) {
17694       {
17695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17696       };
17697     } catch (...) {
17698       {
17699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17700       };
17701     }
17702   }
17703   jresult = (void *)result;
17704   return jresult;
17705 }
17706
17707
17708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17709   void * jresult ;
17710   Dali::Handle *result = 0 ;
17711
17712   {
17713     try {
17714       result = (Dali::Handle *)new Dali::Handle();
17715     } catch (std::out_of_range& e) {
17716       {
17717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17718       };
17719     } catch (std::exception& e) {
17720       {
17721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17722       };
17723     } catch (...) {
17724       {
17725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17726       };
17727     }
17728   }
17729   jresult = (void *)result;
17730   return jresult;
17731 }
17732
17733
17734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17735   void * jresult ;
17736   Dali::Handle result;
17737
17738   {
17739     try {
17740       result = Dali::Handle::New();
17741     } catch (std::out_of_range& e) {
17742       {
17743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17744       };
17745     } catch (std::exception& e) {
17746       {
17747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (...) {
17750       {
17751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17752       };
17753     }
17754   }
17755   jresult = new Dali::Handle((const Dali::Handle &)result);
17756   return jresult;
17757 }
17758
17759
17760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17761   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17762
17763   arg1 = (Dali::Handle *)jarg1;
17764   {
17765     try {
17766       delete arg1;
17767     } catch (std::out_of_range& e) {
17768       {
17769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17770       };
17771     } catch (std::exception& e) {
17772       {
17773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17774       };
17775     } catch (...) {
17776       {
17777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17778       };
17779     }
17780   }
17781 }
17782
17783
17784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17785   void * jresult ;
17786   Dali::Handle *arg1 = 0 ;
17787   Dali::Handle *result = 0 ;
17788
17789   arg1 = (Dali::Handle *)jarg1;
17790   if (!arg1) {
17791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17792     return 0;
17793   }
17794   {
17795     try {
17796       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17797     } catch (std::out_of_range& e) {
17798       {
17799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17800       };
17801     } catch (std::exception& e) {
17802       {
17803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17804       };
17805     } catch (...) {
17806       {
17807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17808       };
17809     }
17810   }
17811   jresult = (void *)result;
17812   return jresult;
17813 }
17814
17815
17816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17817   void * jresult ;
17818   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17819   Dali::Handle *arg2 = 0 ;
17820   Dali::Handle *result = 0 ;
17821
17822   arg1 = (Dali::Handle *)jarg1;
17823   arg2 = (Dali::Handle *)jarg2;
17824   if (!arg2) {
17825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17826     return 0;
17827   }
17828   {
17829     try {
17830       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17831     } catch (std::out_of_range& e) {
17832       {
17833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17834       };
17835     } catch (std::exception& e) {
17836       {
17837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17838       };
17839     } catch (...) {
17840       {
17841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17842       };
17843     }
17844   }
17845   jresult = (void *)result;
17846   return jresult;
17847 }
17848
17849
17850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17851   void * jresult ;
17852   Dali::BaseHandle arg1 ;
17853   Dali::BaseHandle *argp1 ;
17854   Dali::Handle result;
17855
17856   argp1 = (Dali::BaseHandle *)jarg1;
17857   if (!argp1) {
17858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17859     return 0;
17860   }
17861   arg1 = *argp1;
17862   {
17863     try {
17864       result = Dali::Handle::DownCast(arg1);
17865     } catch (std::out_of_range& e) {
17866       {
17867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (std::exception& e) {
17870       {
17871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (...) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17876       };
17877     }
17878   }
17879   jresult = new Dali::Handle((const Dali::Handle &)result);
17880   return jresult;
17881 }
17882
17883
17884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17885   unsigned int jresult ;
17886   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17887   Dali::Handle::Capability arg2 ;
17888   bool result;
17889
17890   arg1 = (Dali::Handle *)jarg1;
17891   arg2 = (Dali::Handle::Capability)jarg2;
17892   {
17893     try {
17894       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17895     } catch (std::out_of_range& e) {
17896       {
17897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17898       };
17899     } catch (std::exception& e) {
17900       {
17901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (...) {
17904       {
17905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17906       };
17907     }
17908   }
17909   jresult = result;
17910   return jresult;
17911 }
17912
17913
17914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17915   unsigned int jresult ;
17916   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17917   unsigned int result;
17918
17919   arg1 = (Dali::Handle *)jarg1;
17920   {
17921     try {
17922       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17923     } catch (std::out_of_range& e) {
17924       {
17925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17926       };
17927     } catch (std::exception& e) {
17928       {
17929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17930       };
17931     } catch (...) {
17932       {
17933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17934       };
17935     }
17936   }
17937   jresult = result;
17938   return jresult;
17939 }
17940
17941
17942 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17943   char * jresult ;
17944   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17945   Dali::Property::Index arg2 ;
17946   std::string result;
17947
17948   arg1 = (Dali::Handle *)jarg1;
17949   arg2 = (Dali::Property::Index)jarg2;
17950   {
17951     try {
17952       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17953     } catch (std::out_of_range& e) {
17954       {
17955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17956       };
17957     } catch (std::exception& e) {
17958       {
17959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17960       };
17961     } catch (...) {
17962       {
17963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17964       };
17965     }
17966   }
17967   jresult = SWIG_csharp_string_callback((&result)->c_str());
17968   return jresult;
17969 }
17970
17971
17972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17973   int jresult ;
17974   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17975   std::string *arg2 = 0 ;
17976   Dali::Property::Index result;
17977
17978   arg1 = (Dali::Handle *)jarg1;
17979   if (!jarg2) {
17980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17981     return 0;
17982   }
17983   std::string arg2_str(jarg2);
17984   arg2 = &arg2_str;
17985   {
17986     try {
17987       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
17988     } catch (std::out_of_range& e) {
17989       {
17990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17991       };
17992     } catch (std::exception& e) {
17993       {
17994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17995       };
17996     } catch (...) {
17997       {
17998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17999       };
18000     }
18001   }
18002   jresult = result;
18003
18004   //argout typemap for const std::string&
18005
18006   return jresult;
18007 }
18008
18009
18010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18011   unsigned int jresult ;
18012   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18013   Dali::Property::Index arg2 ;
18014   bool result;
18015
18016   arg1 = (Dali::Handle *)jarg1;
18017   arg2 = (Dali::Property::Index)jarg2;
18018   {
18019     try {
18020       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18021     } catch (std::out_of_range& e) {
18022       {
18023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18024       };
18025     } catch (std::exception& e) {
18026       {
18027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18028       };
18029     } catch (...) {
18030       {
18031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18032       };
18033     }
18034   }
18035   jresult = result;
18036   return jresult;
18037 }
18038
18039
18040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18041   unsigned int jresult ;
18042   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18043   Dali::Property::Index arg2 ;
18044   bool result;
18045
18046   arg1 = (Dali::Handle *)jarg1;
18047   arg2 = (Dali::Property::Index)jarg2;
18048   {
18049     try {
18050       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18051     } catch (std::out_of_range& e) {
18052       {
18053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18054       };
18055     } catch (std::exception& e) {
18056       {
18057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18058       };
18059     } catch (...) {
18060       {
18061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18062       };
18063     }
18064   }
18065   jresult = result;
18066   return jresult;
18067 }
18068
18069
18070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18071   unsigned int jresult ;
18072   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18073   Dali::Property::Index arg2 ;
18074   bool result;
18075
18076   arg1 = (Dali::Handle *)jarg1;
18077   arg2 = (Dali::Property::Index)jarg2;
18078   {
18079     try {
18080       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18081     } catch (std::out_of_range& e) {
18082       {
18083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18084       };
18085     } catch (std::exception& e) {
18086       {
18087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (...) {
18090       {
18091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18092       };
18093     }
18094   }
18095   jresult = result;
18096   return jresult;
18097 }
18098
18099
18100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18101   int jresult ;
18102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18103   Dali::Property::Index arg2 ;
18104   Dali::Property::Type result;
18105
18106   arg1 = (Dali::Handle *)jarg1;
18107   arg2 = (Dali::Property::Index)jarg2;
18108   {
18109     try {
18110       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18111     } catch (std::out_of_range& e) {
18112       {
18113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18114       };
18115     } catch (std::exception& e) {
18116       {
18117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (...) {
18120       {
18121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18122       };
18123     }
18124   }
18125   jresult = (int)result;
18126   return jresult;
18127 }
18128
18129
18130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18131   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18132   Dali::Property::Index arg2 ;
18133   Dali::Property::Value *arg3 = 0 ;
18134
18135   arg1 = (Dali::Handle *)jarg1;
18136   arg2 = (Dali::Property::Index)jarg2;
18137   arg3 = (Dali::Property::Value *)jarg3;
18138   if (!arg3) {
18139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18140     return ;
18141   }
18142   {
18143     try {
18144       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18145     } catch (std::out_of_range& e) {
18146       {
18147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18148       };
18149     } catch (std::exception& e) {
18150       {
18151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18152       };
18153     } catch (...) {
18154       {
18155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18156       };
18157     }
18158   }
18159 }
18160
18161
18162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18163   int jresult ;
18164   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18165   std::string *arg2 = 0 ;
18166   Dali::Property::Value *arg3 = 0 ;
18167   Dali::Property::Index result;
18168
18169   arg1 = (Dali::Handle *)jarg1;
18170   if (!jarg2) {
18171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18172     return 0;
18173   }
18174   std::string arg2_str(jarg2);
18175   arg2 = &arg2_str;
18176   arg3 = (Dali::Property::Value *)jarg3;
18177   if (!arg3) {
18178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18179     return 0;
18180   }
18181   {
18182     try {
18183       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18184     } catch (std::out_of_range& e) {
18185       {
18186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18187       };
18188     } catch (std::exception& e) {
18189       {
18190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18191       };
18192     } catch (...) {
18193       {
18194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18195       };
18196     }
18197   }
18198   jresult = result;
18199
18200   //argout typemap for const std::string&
18201
18202   return jresult;
18203 }
18204
18205
18206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18207   int jresult ;
18208   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18209   std::string *arg2 = 0 ;
18210   Dali::Property::Value *arg3 = 0 ;
18211   Dali::Property::AccessMode arg4 ;
18212   Dali::Property::Index result;
18213
18214   arg1 = (Dali::Handle *)jarg1;
18215   if (!jarg2) {
18216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18217     return 0;
18218   }
18219   std::string arg2_str(jarg2);
18220   arg2 = &arg2_str;
18221   arg3 = (Dali::Property::Value *)jarg3;
18222   if (!arg3) {
18223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18224     return 0;
18225   }
18226   arg4 = (Dali::Property::AccessMode)jarg4;
18227   {
18228     try {
18229       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18230     } catch (std::out_of_range& e) {
18231       {
18232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18233       };
18234     } catch (std::exception& e) {
18235       {
18236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18237       };
18238     } catch (...) {
18239       {
18240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18241       };
18242     }
18243   }
18244   jresult = result;
18245
18246   //argout typemap for const std::string&
18247
18248   return jresult;
18249 }
18250
18251
18252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18253   void * jresult ;
18254   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18255   Dali::Property::Index arg2 ;
18256   Dali::Property::Value result;
18257
18258   arg1 = (Dali::Handle *)jarg1;
18259   arg2 = (Dali::Property::Index)jarg2;
18260   {
18261     try {
18262       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18263     } catch (std::out_of_range& e) {
18264       {
18265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18266       };
18267     } catch (std::exception& e) {
18268       {
18269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18270       };
18271     } catch (...) {
18272       {
18273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18274       };
18275     }
18276   }
18277   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18278   return jresult;
18279 }
18280
18281
18282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18283   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18284   Dali::Property::IndexContainer *arg2 = 0 ;
18285
18286   arg1 = (Dali::Handle *)jarg1;
18287   arg2 = (Dali::Property::IndexContainer *)jarg2;
18288   if (!arg2) {
18289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18290     return ;
18291   }
18292   {
18293     try {
18294       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18295     } catch (std::out_of_range& e) {
18296       {
18297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18298       };
18299     } catch (std::exception& e) {
18300       {
18301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18302       };
18303     } catch (...) {
18304       {
18305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18306       };
18307     }
18308   }
18309 }
18310
18311
18312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18313   void * jresult ;
18314   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18315   Dali::Property::Index arg2 ;
18316   Dali::PropertyCondition *arg3 = 0 ;
18317   Dali::PropertyNotification result;
18318
18319   arg1 = (Dali::Handle *)jarg1;
18320   arg2 = (Dali::Property::Index)jarg2;
18321   arg3 = (Dali::PropertyCondition *)jarg3;
18322   if (!arg3) {
18323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18324     return 0;
18325   }
18326   {
18327     try {
18328       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18329     } catch (std::out_of_range& e) {
18330       {
18331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18332       };
18333     } catch (std::exception& e) {
18334       {
18335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18336       };
18337     } catch (...) {
18338       {
18339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18340       };
18341     }
18342   }
18343   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18344   return jresult;
18345 }
18346
18347
18348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18349   void * jresult ;
18350   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18351   Dali::Property::Index arg2 ;
18352   int arg3 ;
18353   Dali::PropertyCondition *arg4 = 0 ;
18354   Dali::PropertyNotification result;
18355
18356   arg1 = (Dali::Handle *)jarg1;
18357   arg2 = (Dali::Property::Index)jarg2;
18358   arg3 = (int)jarg3;
18359   arg4 = (Dali::PropertyCondition *)jarg4;
18360   if (!arg4) {
18361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18362     return 0;
18363   }
18364   {
18365     try {
18366       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18367     } catch (std::out_of_range& e) {
18368       {
18369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18370       };
18371     } catch (std::exception& e) {
18372       {
18373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (...) {
18376       {
18377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18378       };
18379     }
18380   }
18381   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18382   return jresult;
18383 }
18384
18385
18386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18387   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18388   Dali::PropertyNotification arg2 ;
18389   Dali::PropertyNotification *argp2 ;
18390
18391   arg1 = (Dali::Handle *)jarg1;
18392   argp2 = (Dali::PropertyNotification *)jarg2;
18393   if (!argp2) {
18394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18395     return ;
18396   }
18397   arg2 = *argp2;
18398   {
18399     try {
18400       (arg1)->RemovePropertyNotification(arg2);
18401     } catch (std::out_of_range& e) {
18402       {
18403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18404       };
18405     } catch (std::exception& e) {
18406       {
18407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18408       };
18409     } catch (...) {
18410       {
18411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18412       };
18413     }
18414   }
18415 }
18416
18417
18418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18419   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18420
18421   arg1 = (Dali::Handle *)jarg1;
18422   {
18423     try {
18424       (arg1)->RemovePropertyNotifications();
18425     } catch (std::out_of_range& e) {
18426       {
18427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18428       };
18429     } catch (std::exception& e) {
18430       {
18431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18432       };
18433     } catch (...) {
18434       {
18435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18436       };
18437     }
18438   }
18439 }
18440
18441
18442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18443   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18444
18445   arg1 = (Dali::Handle *)jarg1;
18446   {
18447     try {
18448       (arg1)->RemoveConstraints();
18449     } catch (std::out_of_range& e) {
18450       {
18451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18452       };
18453     } catch (std::exception& e) {
18454       {
18455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18456       };
18457     } catch (...) {
18458       {
18459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18460       };
18461     }
18462   }
18463 }
18464
18465
18466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18467   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18468   unsigned int arg2 ;
18469
18470   arg1 = (Dali::Handle *)jarg1;
18471   arg2 = (unsigned int)jarg2;
18472   {
18473     try {
18474       (arg1)->RemoveConstraints(arg2);
18475     } catch (std::out_of_range& e) {
18476       {
18477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18478       };
18479     } catch (std::exception& e) {
18480       {
18481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18482       };
18483     } catch (...) {
18484       {
18485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18486       };
18487     }
18488   }
18489 }
18490
18491
18492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18493   int jresult ;
18494   Dali::Property::Index result;
18495
18496   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18497   jresult = result;
18498   return jresult;
18499 }
18500
18501
18502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18503   void * jresult ;
18504   Dali::Handle result;
18505
18506   {
18507     try {
18508       result = Dali::WeightObject::New();
18509     } catch (std::out_of_range& e) {
18510       {
18511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18512       };
18513     } catch (std::exception& e) {
18514       {
18515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18516       };
18517     } catch (...) {
18518       {
18519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18520       };
18521     }
18522   }
18523   jresult = new Dali::Handle((const Dali::Handle &)result);
18524   return jresult;
18525 }
18526
18527
18528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18529   void * jresult ;
18530   Dali::TypeInfo *result = 0 ;
18531
18532   {
18533     try {
18534       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18535     } catch (std::out_of_range& e) {
18536       {
18537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (std::exception& e) {
18540       {
18541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549   jresult = (void *)result;
18550   return jresult;
18551 }
18552
18553
18554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18555   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18556
18557   arg1 = (Dali::TypeInfo *)jarg1;
18558   {
18559     try {
18560       delete arg1;
18561     } catch (std::out_of_range& e) {
18562       {
18563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18564       };
18565     } catch (std::exception& e) {
18566       {
18567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18568       };
18569     } catch (...) {
18570       {
18571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18572       };
18573     }
18574   }
18575 }
18576
18577
18578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18579   void * jresult ;
18580   Dali::TypeInfo *arg1 = 0 ;
18581   Dali::TypeInfo *result = 0 ;
18582
18583   arg1 = (Dali::TypeInfo *)jarg1;
18584   if (!arg1) {
18585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18586     return 0;
18587   }
18588   {
18589     try {
18590       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18591     } catch (std::out_of_range& e) {
18592       {
18593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (std::exception& e) {
18596       {
18597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18598       };
18599     } catch (...) {
18600       {
18601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18602       };
18603     }
18604   }
18605   jresult = (void *)result;
18606   return jresult;
18607 }
18608
18609
18610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18611   void * jresult ;
18612   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18613   Dali::TypeInfo *arg2 = 0 ;
18614   Dali::TypeInfo *result = 0 ;
18615
18616   arg1 = (Dali::TypeInfo *)jarg1;
18617   arg2 = (Dali::TypeInfo *)jarg2;
18618   if (!arg2) {
18619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18620     return 0;
18621   }
18622   {
18623     try {
18624       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18625     } catch (std::out_of_range& e) {
18626       {
18627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18628       };
18629     } catch (std::exception& e) {
18630       {
18631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18632       };
18633     } catch (...) {
18634       {
18635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18636       };
18637     }
18638   }
18639   jresult = (void *)result;
18640   return jresult;
18641 }
18642
18643
18644 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18645   char * jresult ;
18646   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18647   std::string *result = 0 ;
18648
18649   arg1 = (Dali::TypeInfo *)jarg1;
18650   {
18651     try {
18652       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18653     } catch (std::out_of_range& e) {
18654       {
18655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18656       };
18657     } catch (std::exception& e) {
18658       {
18659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18660       };
18661     } catch (...) {
18662       {
18663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18664       };
18665     }
18666   }
18667   jresult = SWIG_csharp_string_callback(result->c_str());
18668   return jresult;
18669 }
18670
18671
18672 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18673   char * jresult ;
18674   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18675   std::string *result = 0 ;
18676
18677   arg1 = (Dali::TypeInfo *)jarg1;
18678   {
18679     try {
18680       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18681     } catch (std::out_of_range& e) {
18682       {
18683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18684       };
18685     } catch (std::exception& e) {
18686       {
18687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18688       };
18689     } catch (...) {
18690       {
18691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18692       };
18693     }
18694   }
18695   jresult = SWIG_csharp_string_callback(result->c_str());
18696   return jresult;
18697 }
18698
18699
18700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18701   void * jresult ;
18702   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18703   Dali::BaseHandle result;
18704
18705   arg1 = (Dali::TypeInfo *)jarg1;
18706   {
18707     try {
18708       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18709     } catch (std::out_of_range& e) {
18710       {
18711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (std::exception& e) {
18714       {
18715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18724   return jresult;
18725 }
18726
18727
18728 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18729   unsigned long jresult ;
18730   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18731   size_t result;
18732
18733   arg1 = (Dali::TypeInfo *)jarg1;
18734   {
18735     try {
18736       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18737     } catch (std::out_of_range& e) {
18738       {
18739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18740       };
18741     } catch (std::exception& e) {
18742       {
18743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18744       };
18745     } catch (...) {
18746       {
18747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18748       };
18749     }
18750   }
18751   jresult = (unsigned long)result;
18752   return jresult;
18753 }
18754
18755
18756 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18757   char * jresult ;
18758   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18759   size_t arg2 ;
18760   std::string result;
18761
18762   arg1 = (Dali::TypeInfo *)jarg1;
18763   arg2 = (size_t)jarg2;
18764   {
18765     try {
18766       result = (arg1)->GetActionName(arg2);
18767     } catch (std::out_of_range& e) {
18768       {
18769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18770       };
18771     } catch (std::exception& e) {
18772       {
18773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18774       };
18775     } catch (...) {
18776       {
18777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18778       };
18779     }
18780   }
18781   jresult = SWIG_csharp_string_callback((&result)->c_str());
18782   return jresult;
18783 }
18784
18785
18786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18787   unsigned long jresult ;
18788   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18789   size_t result;
18790
18791   arg1 = (Dali::TypeInfo *)jarg1;
18792   {
18793     try {
18794       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18795     } catch (std::out_of_range& e) {
18796       {
18797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (std::exception& e) {
18800       {
18801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18802       };
18803     } catch (...) {
18804       {
18805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18806       };
18807     }
18808   }
18809   jresult = (unsigned long)result;
18810   return jresult;
18811 }
18812
18813
18814 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18815   char * jresult ;
18816   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18817   size_t arg2 ;
18818   std::string result;
18819
18820   arg1 = (Dali::TypeInfo *)jarg1;
18821   arg2 = (size_t)jarg2;
18822   {
18823     try {
18824       result = (arg1)->GetSignalName(arg2);
18825     } catch (std::out_of_range& e) {
18826       {
18827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18828       };
18829     } catch (std::exception& e) {
18830       {
18831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18832       };
18833     } catch (...) {
18834       {
18835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18836       };
18837     }
18838   }
18839   jresult = SWIG_csharp_string_callback((&result)->c_str());
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18845   unsigned long jresult ;
18846   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18847   size_t result;
18848
18849   arg1 = (Dali::TypeInfo *)jarg1;
18850   {
18851     try {
18852       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18860       };
18861     } catch (...) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18864       };
18865     }
18866   }
18867   jresult = (unsigned long)result;
18868   return jresult;
18869 }
18870
18871
18872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18873   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18874   Dali::Property::IndexContainer *arg2 = 0 ;
18875
18876   arg1 = (Dali::TypeInfo *)jarg1;
18877   arg2 = (Dali::Property::IndexContainer *)jarg2;
18878   if (!arg2) {
18879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18880     return ;
18881   }
18882   {
18883     try {
18884       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18885     } catch (std::out_of_range& e) {
18886       {
18887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18888       };
18889     } catch (std::exception& e) {
18890       {
18891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18892       };
18893     } catch (...) {
18894       {
18895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18896       };
18897     }
18898   }
18899 }
18900
18901
18902 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18903   char * jresult ;
18904   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18905   Dali::Property::Index arg2 ;
18906   std::string *result = 0 ;
18907
18908   arg1 = (Dali::TypeInfo *)jarg1;
18909   arg2 = (Dali::Property::Index)jarg2;
18910   {
18911     try {
18912       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18913     } catch (std::out_of_range& e) {
18914       {
18915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18916       };
18917     } catch (std::exception& e) {
18918       {
18919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18920       };
18921     } catch (...) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18924       };
18925     }
18926   }
18927   jresult = SWIG_csharp_string_callback(result->c_str());
18928   return jresult;
18929 }
18930
18931
18932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18933   void * jresult ;
18934   Dali::TypeRegistry result;
18935
18936   {
18937     try {
18938       result = Dali::TypeRegistry::Get();
18939     } catch (std::out_of_range& e) {
18940       {
18941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18942       };
18943     } catch (std::exception& e) {
18944       {
18945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18946       };
18947     } catch (...) {
18948       {
18949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18950       };
18951     }
18952   }
18953   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18954   return jresult;
18955 }
18956
18957
18958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18959   void * jresult ;
18960   Dali::TypeRegistry *result = 0 ;
18961
18962   {
18963     try {
18964       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18965     } catch (std::out_of_range& e) {
18966       {
18967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18968       };
18969     } catch (std::exception& e) {
18970       {
18971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18972       };
18973     } catch (...) {
18974       {
18975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18976       };
18977     }
18978   }
18979   jresult = (void *)result;
18980   return jresult;
18981 }
18982
18983
18984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
18985   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
18986
18987   arg1 = (Dali::TypeRegistry *)jarg1;
18988   {
18989     try {
18990       delete arg1;
18991     } catch (std::out_of_range& e) {
18992       {
18993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (std::exception& e) {
18996       {
18997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18998       };
18999     } catch (...) {
19000       {
19001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19002       };
19003     }
19004   }
19005 }
19006
19007
19008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19009   void * jresult ;
19010   Dali::TypeRegistry *arg1 = 0 ;
19011   Dali::TypeRegistry *result = 0 ;
19012
19013   arg1 = (Dali::TypeRegistry *)jarg1;
19014   if (!arg1) {
19015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19016     return 0;
19017   }
19018   {
19019     try {
19020       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19021     } catch (std::out_of_range& e) {
19022       {
19023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19024       };
19025     } catch (std::exception& e) {
19026       {
19027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19028       };
19029     } catch (...) {
19030       {
19031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19032       };
19033     }
19034   }
19035   jresult = (void *)result;
19036   return jresult;
19037 }
19038
19039
19040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19041   void * jresult ;
19042   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19043   Dali::TypeRegistry *arg2 = 0 ;
19044   Dali::TypeRegistry *result = 0 ;
19045
19046   arg1 = (Dali::TypeRegistry *)jarg1;
19047   arg2 = (Dali::TypeRegistry *)jarg2;
19048   if (!arg2) {
19049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19050     return 0;
19051   }
19052   {
19053     try {
19054       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19055     } catch (std::out_of_range& e) {
19056       {
19057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19058       };
19059     } catch (std::exception& e) {
19060       {
19061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19062       };
19063     } catch (...) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19066       };
19067     }
19068   }
19069   jresult = (void *)result;
19070   return jresult;
19071 }
19072
19073
19074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19075   void * jresult ;
19076   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19077   std::string *arg2 = 0 ;
19078   Dali::TypeInfo result;
19079
19080   arg1 = (Dali::TypeRegistry *)jarg1;
19081   if (!jarg2) {
19082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19083     return 0;
19084   }
19085   std::string arg2_str(jarg2);
19086   arg2 = &arg2_str;
19087   {
19088     try {
19089       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19090     } catch (std::out_of_range& e) {
19091       {
19092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19093       };
19094     } catch (std::exception& e) {
19095       {
19096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19097       };
19098     } catch (...) {
19099       {
19100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19101       };
19102     }
19103   }
19104   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19105
19106   //argout typemap for const std::string&
19107
19108   return jresult;
19109 }
19110
19111
19112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19113   void * jresult ;
19114   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19115   std::type_info *arg2 = 0 ;
19116   Dali::TypeInfo result;
19117
19118   arg1 = (Dali::TypeRegistry *)jarg1;
19119   arg2 = (std::type_info *)jarg2;
19120   if (!arg2) {
19121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19122     return 0;
19123   }
19124   {
19125     try {
19126       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19127     } catch (std::out_of_range& e) {
19128       {
19129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19130       };
19131     } catch (std::exception& e) {
19132       {
19133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19134       };
19135     } catch (...) {
19136       {
19137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19138       };
19139     }
19140   }
19141   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19142   return jresult;
19143 }
19144
19145
19146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19147   unsigned long jresult ;
19148   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19149   size_t result;
19150
19151   arg1 = (Dali::TypeRegistry *)jarg1;
19152   {
19153     try {
19154       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19155     } catch (std::out_of_range& e) {
19156       {
19157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19158       };
19159     } catch (std::exception& e) {
19160       {
19161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (...) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19166       };
19167     }
19168   }
19169   jresult = (unsigned long)result;
19170   return jresult;
19171 }
19172
19173
19174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19175   char * jresult ;
19176   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19177   size_t arg2 ;
19178   std::string result;
19179
19180   arg1 = (Dali::TypeRegistry *)jarg1;
19181   arg2 = (size_t)jarg2;
19182   {
19183     try {
19184       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19185     } catch (std::out_of_range& e) {
19186       {
19187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19188       };
19189     } catch (std::exception& e) {
19190       {
19191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19192       };
19193     } catch (...) {
19194       {
19195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19196       };
19197     }
19198   }
19199   jresult = SWIG_csharp_string_callback((&result)->c_str());
19200   return jresult;
19201 }
19202
19203
19204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19205   void * jresult ;
19206   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19207   Dali::TypeRegistry *result = 0 ;
19208
19209   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19210   {
19211     try {
19212       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19213     } catch (std::out_of_range& e) {
19214       {
19215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19216       };
19217     } catch (std::exception& e) {
19218       {
19219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19220       };
19221     } catch (...) {
19222       {
19223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19224       };
19225     }
19226   }
19227   jresult = (void *)result;
19228   return jresult;
19229 }
19230
19231
19232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19233   void * jresult ;
19234   std::type_info *arg1 = 0 ;
19235   std::type_info *arg2 = 0 ;
19236   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19237   Dali::TypeRegistration *result = 0 ;
19238
19239   arg1 = (std::type_info *)jarg1;
19240   if (!arg1) {
19241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19242     return 0;
19243   }
19244   arg2 = (std::type_info *)jarg2;
19245   if (!arg2) {
19246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19247     return 0;
19248   }
19249   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19250   {
19251     try {
19252       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19253     } catch (std::out_of_range& e) {
19254       {
19255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19256       };
19257     } catch (std::exception& e) {
19258       {
19259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19260       };
19261     } catch (...) {
19262       {
19263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19264       };
19265     }
19266   }
19267   jresult = (void *)result;
19268   return jresult;
19269 }
19270
19271
19272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19273   void * jresult ;
19274   std::type_info *arg1 = 0 ;
19275   std::type_info *arg2 = 0 ;
19276   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19277   bool arg4 ;
19278   Dali::TypeRegistration *result = 0 ;
19279
19280   arg1 = (std::type_info *)jarg1;
19281   if (!arg1) {
19282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19283     return 0;
19284   }
19285   arg2 = (std::type_info *)jarg2;
19286   if (!arg2) {
19287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19288     return 0;
19289   }
19290   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19291   arg4 = jarg4 ? true : false;
19292   {
19293     try {
19294       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19295     } catch (std::out_of_range& e) {
19296       {
19297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (std::exception& e) {
19300       {
19301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (...) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19306       };
19307     }
19308   }
19309   jresult = (void *)result;
19310   return jresult;
19311 }
19312
19313
19314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19315   void * jresult ;
19316   std::string *arg1 = 0 ;
19317   std::type_info *arg2 = 0 ;
19318   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19319   Dali::TypeRegistration *result = 0 ;
19320
19321   if (!jarg1) {
19322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19323     return 0;
19324   }
19325   std::string arg1_str(jarg1);
19326   arg1 = &arg1_str;
19327   arg2 = (std::type_info *)jarg2;
19328   if (!arg2) {
19329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19330     return 0;
19331   }
19332   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19333   {
19334     try {
19335       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19336     } catch (std::out_of_range& e) {
19337       {
19338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (std::exception& e) {
19341       {
19342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350   jresult = (void *)result;
19351
19352   //argout typemap for const std::string&
19353
19354   return jresult;
19355 }
19356
19357
19358 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19359   char * jresult ;
19360   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19361   std::string result;
19362
19363   arg1 = (Dali::TypeRegistration *)jarg1;
19364   {
19365     try {
19366       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19367     } catch (std::out_of_range& e) {
19368       {
19369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19370       };
19371     } catch (std::exception& e) {
19372       {
19373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19374       };
19375     } catch (...) {
19376       {
19377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19378       };
19379     }
19380   }
19381   jresult = SWIG_csharp_string_callback((&result)->c_str());
19382   return jresult;
19383 }
19384
19385
19386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19387   std::string *arg1 = 0 ;
19388   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19389
19390   if (!jarg1) {
19391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19392     return ;
19393   }
19394   std::string arg1_str(jarg1);
19395   arg1 = &arg1_str;
19396   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19397   {
19398     try {
19399       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19400     } catch (std::out_of_range& e) {
19401       {
19402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19403       };
19404     } catch (std::exception& e) {
19405       {
19406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19411       };
19412     }
19413   }
19414
19415   //argout typemap for const std::string&
19416
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19421   std::string *arg1 = 0 ;
19422   std::string *arg2 = 0 ;
19423   int arg3 ;
19424   Dali::Property::Type arg4 ;
19425   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19426   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19427
19428   if (!jarg1) {
19429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19430     return ;
19431   }
19432   std::string arg1_str(jarg1);
19433   arg1 = &arg1_str;
19434   if (!jarg2) {
19435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19436     return ;
19437   }
19438   std::string arg2_str(jarg2);
19439   arg2 = &arg2_str;
19440   arg3 = (int)jarg3;
19441   arg4 = (Dali::Property::Type)jarg4;
19442   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19443   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19444   {
19445     try {
19446       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19447     } catch (std::out_of_range& e) {
19448       {
19449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19450       };
19451     } catch (std::exception& e) {
19452       {
19453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19454       };
19455     } catch (...) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19458       };
19459     }
19460   }
19461
19462   //argout typemap for const std::string&
19463
19464
19465   //argout typemap for const std::string&
19466
19467 }
19468
19469
19470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19471   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19472
19473   arg1 = (Dali::TypeRegistration *)jarg1;
19474   {
19475     try {
19476       delete arg1;
19477     } catch (std::out_of_range& e) {
19478       {
19479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19480       };
19481     } catch (std::exception& e) {
19482       {
19483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19484       };
19485     } catch (...) {
19486       {
19487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19488       };
19489     }
19490   }
19491 }
19492
19493
19494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19495   void * jresult ;
19496   Dali::TypeRegistration *arg1 = 0 ;
19497   std::string *arg2 = 0 ;
19498   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19499   Dali::SignalConnectorType *result = 0 ;
19500
19501   arg1 = (Dali::TypeRegistration *)jarg1;
19502   if (!arg1) {
19503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19504     return 0;
19505   }
19506   if (!jarg2) {
19507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19508     return 0;
19509   }
19510   std::string arg2_str(jarg2);
19511   arg2 = &arg2_str;
19512   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19513   {
19514     try {
19515       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19516     } catch (std::out_of_range& e) {
19517       {
19518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19519       };
19520     } catch (std::exception& e) {
19521       {
19522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19523       };
19524     } catch (...) {
19525       {
19526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19527       };
19528     }
19529   }
19530   jresult = (void *)result;
19531
19532   //argout typemap for const std::string&
19533
19534   return jresult;
19535 }
19536
19537
19538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19539   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19540
19541   arg1 = (Dali::SignalConnectorType *)jarg1;
19542   {
19543     try {
19544       delete arg1;
19545     } catch (std::out_of_range& e) {
19546       {
19547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19548       };
19549     } catch (std::exception& e) {
19550       {
19551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19552       };
19553     } catch (...) {
19554       {
19555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19556       };
19557     }
19558   }
19559 }
19560
19561
19562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19563   void * jresult ;
19564   Dali::TypeRegistration *arg1 = 0 ;
19565   std::string *arg2 = 0 ;
19566   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19567   Dali::TypeAction *result = 0 ;
19568
19569   arg1 = (Dali::TypeRegistration *)jarg1;
19570   if (!arg1) {
19571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19572     return 0;
19573   }
19574   if (!jarg2) {
19575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19576     return 0;
19577   }
19578   std::string arg2_str(jarg2);
19579   arg2 = &arg2_str;
19580   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19581   {
19582     try {
19583       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19584     } catch (std::out_of_range& e) {
19585       {
19586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (std::exception& e) {
19589       {
19590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (...) {
19593       {
19594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19595       };
19596     }
19597   }
19598   jresult = (void *)result;
19599
19600   //argout typemap for const std::string&
19601
19602   return jresult;
19603 }
19604
19605
19606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19607   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19608
19609   arg1 = (Dali::TypeAction *)jarg1;
19610   {
19611     try {
19612       delete arg1;
19613     } catch (std::out_of_range& e) {
19614       {
19615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19616       };
19617     } catch (std::exception& e) {
19618       {
19619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19620       };
19621     } catch (...) {
19622       {
19623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19624       };
19625     }
19626   }
19627 }
19628
19629
19630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19631   void * jresult ;
19632   Dali::TypeRegistration *arg1 = 0 ;
19633   std::string *arg2 = 0 ;
19634   Dali::Property::Index arg3 ;
19635   Dali::Property::Type arg4 ;
19636   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19637   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19638   Dali::PropertyRegistration *result = 0 ;
19639
19640   arg1 = (Dali::TypeRegistration *)jarg1;
19641   if (!arg1) {
19642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19643     return 0;
19644   }
19645   if (!jarg2) {
19646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19647     return 0;
19648   }
19649   std::string arg2_str(jarg2);
19650   arg2 = &arg2_str;
19651   arg3 = (Dali::Property::Index)jarg3;
19652   arg4 = (Dali::Property::Type)jarg4;
19653   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19654   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19655   {
19656     try {
19657       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (...) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19669       };
19670     }
19671   }
19672   jresult = (void *)result;
19673
19674   //argout typemap for const std::string&
19675
19676   return jresult;
19677 }
19678
19679
19680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19681   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19682
19683   arg1 = (Dali::PropertyRegistration *)jarg1;
19684   {
19685     try {
19686       delete arg1;
19687     } catch (std::out_of_range& e) {
19688       {
19689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19690       };
19691     } catch (std::exception& e) {
19692       {
19693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19694       };
19695     } catch (...) {
19696       {
19697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19698       };
19699     }
19700   }
19701 }
19702
19703
19704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19705   void * jresult ;
19706   Dali::TypeRegistration *arg1 = 0 ;
19707   std::string *arg2 = 0 ;
19708   Dali::Property::Index arg3 ;
19709   Dali::Property::Type arg4 ;
19710   Dali::AnimatablePropertyRegistration *result = 0 ;
19711
19712   arg1 = (Dali::TypeRegistration *)jarg1;
19713   if (!arg1) {
19714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19715     return 0;
19716   }
19717   if (!jarg2) {
19718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19719     return 0;
19720   }
19721   std::string arg2_str(jarg2);
19722   arg2 = &arg2_str;
19723   arg3 = (Dali::Property::Index)jarg3;
19724   arg4 = (Dali::Property::Type)jarg4;
19725   {
19726     try {
19727       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (...) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19739       };
19740     }
19741   }
19742   jresult = (void *)result;
19743
19744   //argout typemap for const std::string&
19745
19746   return jresult;
19747 }
19748
19749
19750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19751   void * jresult ;
19752   Dali::TypeRegistration *arg1 = 0 ;
19753   std::string *arg2 = 0 ;
19754   Dali::Property::Index arg3 ;
19755   Dali::Property::Value *arg4 = 0 ;
19756   Dali::AnimatablePropertyRegistration *result = 0 ;
19757
19758   arg1 = (Dali::TypeRegistration *)jarg1;
19759   if (!arg1) {
19760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19761     return 0;
19762   }
19763   if (!jarg2) {
19764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19765     return 0;
19766   }
19767   std::string arg2_str(jarg2);
19768   arg2 = &arg2_str;
19769   arg3 = (Dali::Property::Index)jarg3;
19770   arg4 = (Dali::Property::Value *)jarg4;
19771   if (!arg4) {
19772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19773     return 0;
19774   }
19775   {
19776     try {
19777       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19778     } catch (std::out_of_range& e) {
19779       {
19780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19781       };
19782     } catch (std::exception& e) {
19783       {
19784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19785       };
19786     } catch (...) {
19787       {
19788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19789       };
19790     }
19791   }
19792   jresult = (void *)result;
19793
19794   //argout typemap for const std::string&
19795
19796   return jresult;
19797 }
19798
19799
19800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19801   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19802
19803   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19804   {
19805     try {
19806       delete arg1;
19807     } catch (std::out_of_range& e) {
19808       {
19809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19810       };
19811     } catch (std::exception& e) {
19812       {
19813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19814       };
19815     } catch (...) {
19816       {
19817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19818       };
19819     }
19820   }
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19825   void * jresult ;
19826   Dali::TypeRegistration *arg1 = 0 ;
19827   std::string *arg2 = 0 ;
19828   Dali::Property::Index arg3 ;
19829   Dali::Property::Index arg4 ;
19830   unsigned int arg5 ;
19831   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19832
19833   arg1 = (Dali::TypeRegistration *)jarg1;
19834   if (!arg1) {
19835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19836     return 0;
19837   }
19838   if (!jarg2) {
19839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19840     return 0;
19841   }
19842   std::string arg2_str(jarg2);
19843   arg2 = &arg2_str;
19844   arg3 = (Dali::Property::Index)jarg3;
19845   arg4 = (Dali::Property::Index)jarg4;
19846   arg5 = (unsigned int)jarg5;
19847   {
19848     try {
19849       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19850     } catch (std::out_of_range& e) {
19851       {
19852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19853       };
19854     } catch (std::exception& e) {
19855       {
19856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19857       };
19858     } catch (...) {
19859       {
19860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19861       };
19862     }
19863   }
19864   jresult = (void *)result;
19865
19866   //argout typemap for const std::string&
19867
19868   return jresult;
19869 }
19870
19871
19872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19873   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19874
19875   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19876   {
19877     try {
19878       delete arg1;
19879     } catch (std::out_of_range& e) {
19880       {
19881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19882       };
19883     } catch (std::exception& e) {
19884       {
19885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19886       };
19887     } catch (...) {
19888       {
19889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19890       };
19891     }
19892   }
19893 }
19894
19895
19896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19897   void * jresult ;
19898   Dali::TypeRegistration *arg1 = 0 ;
19899   std::string *arg2 = 0 ;
19900   Dali::Property::Index arg3 ;
19901   Dali::Property::Type arg4 ;
19902   Dali::ChildPropertyRegistration *result = 0 ;
19903
19904   arg1 = (Dali::TypeRegistration *)jarg1;
19905   if (!arg1) {
19906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19907     return 0;
19908   }
19909   if (!jarg2) {
19910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19911     return 0;
19912   }
19913   std::string arg2_str(jarg2);
19914   arg2 = &arg2_str;
19915   arg3 = (Dali::Property::Index)jarg3;
19916   arg4 = (Dali::Property::Type)jarg4;
19917   {
19918     try {
19919       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19920     } catch (std::out_of_range& e) {
19921       {
19922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19923       };
19924     } catch (std::exception& e) {
19925       {
19926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19927       };
19928     } catch (...) {
19929       {
19930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19931       };
19932     }
19933   }
19934   jresult = (void *)result;
19935
19936   //argout typemap for const std::string&
19937
19938   return jresult;
19939 }
19940
19941
19942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19943   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19944
19945   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19946   {
19947     try {
19948       delete arg1;
19949     } catch (std::out_of_range& e) {
19950       {
19951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19952       };
19953     } catch (std::exception& e) {
19954       {
19955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19956       };
19957     } catch (...) {
19958       {
19959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19960       };
19961     }
19962   }
19963 }
19964
19965
19966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19967   unsigned int jresult ;
19968   std::string *arg1 = 0 ;
19969   std::type_info *arg2 = 0 ;
19970   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19971   bool result;
19972
19973   if (!jarg1) {
19974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19975     return 0;
19976   }
19977   std::string arg1_str(jarg1);
19978   arg1 = &arg1_str;
19979   arg2 = (std::type_info *)jarg2;
19980   if (!arg2) {
19981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19982     return 0;
19983   }
19984   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
19985   {
19986     try {
19987       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19988     } catch (std::out_of_range& e) {
19989       {
19990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19991       };
19992     } catch (std::exception& e) {
19993       {
19994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19995       };
19996     } catch (...) {
19997       {
19998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19999       };
20000     }
20001   }
20002   jresult = result;
20003
20004   //argout typemap for const std::string&
20005
20006   return jresult;
20007 }
20008
20009
20010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20011   unsigned int jresult ;
20012   std::string *arg1 = 0 ;
20013   std::string *arg2 = 0 ;
20014   Dali::Property::Index arg3 ;
20015   Dali::Property::Type arg4 ;
20016   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20017   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20018   bool result;
20019
20020   if (!jarg1) {
20021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20022     return 0;
20023   }
20024   std::string arg1_str(jarg1);
20025   arg1 = &arg1_str;
20026   if (!jarg2) {
20027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20028     return 0;
20029   }
20030   std::string arg2_str(jarg2);
20031   arg2 = &arg2_str;
20032   arg3 = (Dali::Property::Index)jarg3;
20033   arg4 = (Dali::Property::Type)jarg4;
20034   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20035   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20036   {
20037     try {
20038       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20039     } catch (std::out_of_range& e) {
20040       {
20041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (std::exception& e) {
20044       {
20045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20046       };
20047     } catch (...) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20050       };
20051     }
20052   }
20053   jresult = result;
20054
20055   //argout typemap for const std::string&
20056
20057
20058   //argout typemap for const std::string&
20059
20060   return jresult;
20061 }
20062
20063
20064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20065   float jresult ;
20066   float result;
20067
20068   result = (float)(float)Dali::ParentOrigin::TOP;
20069   jresult = result;
20070   return jresult;
20071 }
20072
20073
20074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20075   float jresult ;
20076   float result;
20077
20078   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20079   jresult = result;
20080   return jresult;
20081 }
20082
20083
20084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20085   float jresult ;
20086   float result;
20087
20088   result = (float)(float)Dali::ParentOrigin::LEFT;
20089   jresult = result;
20090   return jresult;
20091 }
20092
20093
20094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20095   float jresult ;
20096   float result;
20097
20098   result = (float)(float)Dali::ParentOrigin::RIGHT;
20099   jresult = result;
20100   return jresult;
20101 }
20102
20103
20104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20105   float jresult ;
20106   float result;
20107
20108   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20109   jresult = result;
20110   return jresult;
20111 }
20112
20113
20114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20115   void * jresult ;
20116   Dali::Vector3 *result = 0 ;
20117
20118   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20119   jresult = (void *)result;
20120   return jresult;
20121 }
20122
20123
20124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20125   void * jresult ;
20126   Dali::Vector3 *result = 0 ;
20127
20128   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20129   jresult = (void *)result;
20130   return jresult;
20131 }
20132
20133
20134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20135   void * jresult ;
20136   Dali::Vector3 *result = 0 ;
20137
20138   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20139   jresult = (void *)result;
20140   return jresult;
20141 }
20142
20143
20144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20145   void * jresult ;
20146   Dali::Vector3 *result = 0 ;
20147
20148   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20149   jresult = (void *)result;
20150   return jresult;
20151 }
20152
20153
20154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20155   void * jresult ;
20156   Dali::Vector3 *result = 0 ;
20157
20158   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20159   jresult = (void *)result;
20160   return jresult;
20161 }
20162
20163
20164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20165   void * jresult ;
20166   Dali::Vector3 *result = 0 ;
20167
20168   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20169   jresult = (void *)result;
20170   return jresult;
20171 }
20172
20173
20174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20175   void * jresult ;
20176   Dali::Vector3 *result = 0 ;
20177
20178   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20179   jresult = (void *)result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20185   void * jresult ;
20186   Dali::Vector3 *result = 0 ;
20187
20188   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20189   jresult = (void *)result;
20190   return jresult;
20191 }
20192
20193
20194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20195   void * jresult ;
20196   Dali::Vector3 *result = 0 ;
20197
20198   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20199   jresult = (void *)result;
20200   return jresult;
20201 }
20202
20203
20204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20205   float jresult ;
20206   float result;
20207
20208   result = (float)(float)Dali::AnchorPoint::TOP;
20209   jresult = result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20215   float jresult ;
20216   float result;
20217
20218   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20219   jresult = result;
20220   return jresult;
20221 }
20222
20223
20224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20225   float jresult ;
20226   float result;
20227
20228   result = (float)(float)Dali::AnchorPoint::LEFT;
20229   jresult = result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20235   float jresult ;
20236   float result;
20237
20238   result = (float)(float)Dali::AnchorPoint::RIGHT;
20239   jresult = result;
20240   return jresult;
20241 }
20242
20243
20244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20245   float jresult ;
20246   float result;
20247
20248   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20249   jresult = result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20255   void * jresult ;
20256   Dali::Vector3 *result = 0 ;
20257
20258   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20259   jresult = (void *)result;
20260   return jresult;
20261 }
20262
20263
20264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20265   void * jresult ;
20266   Dali::Vector3 *result = 0 ;
20267
20268   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20269   jresult = (void *)result;
20270   return jresult;
20271 }
20272
20273
20274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20275   void * jresult ;
20276   Dali::Vector3 *result = 0 ;
20277
20278   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20279   jresult = (void *)result;
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20285   void * jresult ;
20286   Dali::Vector3 *result = 0 ;
20287
20288   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20289   jresult = (void *)result;
20290   return jresult;
20291 }
20292
20293
20294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20295   void * jresult ;
20296   Dali::Vector3 *result = 0 ;
20297
20298   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20299   jresult = (void *)result;
20300   return jresult;
20301 }
20302
20303
20304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20305   void * jresult ;
20306   Dali::Vector3 *result = 0 ;
20307
20308   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20309   jresult = (void *)result;
20310   return jresult;
20311 }
20312
20313
20314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20315   void * jresult ;
20316   Dali::Vector3 *result = 0 ;
20317
20318   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20319   jresult = (void *)result;
20320   return jresult;
20321 }
20322
20323
20324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20325   void * jresult ;
20326   Dali::Vector3 *result = 0 ;
20327
20328   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20329   jresult = (void *)result;
20330   return jresult;
20331 }
20332
20333
20334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20335   void * jresult ;
20336   Dali::Vector3 *result = 0 ;
20337
20338   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20339   jresult = (void *)result;
20340   return jresult;
20341 }
20342
20343
20344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20345   void * jresult ;
20346   Dali::Vector4 *result = 0 ;
20347
20348   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20355   void * jresult ;
20356   Dali::Vector4 *result = 0 ;
20357
20358   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20359   jresult = (void *)result;
20360   return jresult;
20361 }
20362
20363
20364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20365   void * jresult ;
20366   Dali::Vector4 *result = 0 ;
20367
20368   result = (Dali::Vector4 *)&Dali::Color::RED;
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20375   void * jresult ;
20376   Dali::Vector4 *result = 0 ;
20377
20378   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20379   jresult = (void *)result;
20380   return jresult;
20381 }
20382
20383
20384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20385   void * jresult ;
20386   Dali::Vector4 *result = 0 ;
20387
20388   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20389   jresult = (void *)result;
20390   return jresult;
20391 }
20392
20393
20394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20395   void * jresult ;
20396   Dali::Vector4 *result = 0 ;
20397
20398   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20399   jresult = (void *)result;
20400   return jresult;
20401 }
20402
20403
20404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20405   void * jresult ;
20406   Dali::Vector4 *result = 0 ;
20407
20408   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20409   jresult = (void *)result;
20410   return jresult;
20411 }
20412
20413
20414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20415   void * jresult ;
20416   Dali::Vector4 *result = 0 ;
20417
20418   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20419   jresult = (void *)result;
20420   return jresult;
20421 }
20422
20423
20424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20425   void * jresult ;
20426   Dali::Vector4 *result = 0 ;
20427
20428   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20429   jresult = (void *)result;
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20435   float jresult ;
20436   float result;
20437
20438   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20439   jresult = result;
20440   return jresult;
20441 }
20442
20443
20444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20445   float jresult ;
20446   float result;
20447
20448   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20449   jresult = result;
20450   return jresult;
20451 }
20452
20453
20454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20455   float jresult ;
20456   float result;
20457
20458   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20459   jresult = result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20465   float jresult ;
20466   float result;
20467
20468   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20469   jresult = result;
20470   return jresult;
20471 }
20472
20473
20474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20475   float jresult ;
20476   float result;
20477
20478   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20479   jresult = result;
20480   return jresult;
20481 }
20482
20483
20484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20485   float jresult ;
20486   float result;
20487
20488   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20489   jresult = result;
20490   return jresult;
20491 }
20492
20493
20494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20495   float jresult ;
20496   float result;
20497
20498   result = (float)(float)Dali::Math::PI;
20499   jresult = result;
20500   return jresult;
20501 }
20502
20503
20504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20505   float jresult ;
20506   float result;
20507
20508   result = (float)(float)Dali::Math::PI_2;
20509   jresult = result;
20510   return jresult;
20511 }
20512
20513
20514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20515   float jresult ;
20516   float result;
20517
20518   result = (float)(float)Dali::Math::PI_4;
20519   jresult = result;
20520   return jresult;
20521 }
20522
20523
20524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20525   float jresult ;
20526   float result;
20527
20528   result = (float)(float)Dali::Math::PI_OVER_180;
20529   jresult = result;
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20535   float jresult ;
20536   float result;
20537
20538   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20539   jresult = result;
20540   return jresult;
20541 }
20542
20543
20544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20545   int jresult ;
20546   Dali::ResizePolicy::Type result;
20547
20548   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20549   jresult = (int)result;
20550   return jresult;
20551 }
20552
20553
20554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20555   unsigned long jresult ;
20556   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20557   Dali::VectorBase::SizeType result;
20558
20559   arg1 = (Dali::VectorBase *)jarg1;
20560   {
20561     try {
20562       result = ((Dali::VectorBase const *)arg1)->Count();
20563     } catch (std::out_of_range& e) {
20564       {
20565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20566       };
20567     } catch (std::exception& e) {
20568       {
20569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20570       };
20571     } catch (...) {
20572       {
20573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20574       };
20575     }
20576   }
20577   jresult = (unsigned long)result;
20578   return jresult;
20579 }
20580
20581
20582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20583   unsigned long jresult ;
20584   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20585   Dali::VectorBase::SizeType result;
20586
20587   arg1 = (Dali::VectorBase *)jarg1;
20588   {
20589     try {
20590       result = ((Dali::VectorBase const *)arg1)->Size();
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20598       };
20599     } catch (...) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20602       };
20603     }
20604   }
20605   jresult = (unsigned long)result;
20606   return jresult;
20607 }
20608
20609
20610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20611   unsigned int jresult ;
20612   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20613   bool result;
20614
20615   arg1 = (Dali::VectorBase *)jarg1;
20616   {
20617     try {
20618       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20619     } catch (std::out_of_range& e) {
20620       {
20621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20622       };
20623     } catch (std::exception& e) {
20624       {
20625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (...) {
20628       {
20629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20630       };
20631     }
20632   }
20633   jresult = result;
20634   return jresult;
20635 }
20636
20637
20638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20639   unsigned long jresult ;
20640   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20641   Dali::VectorBase::SizeType result;
20642
20643   arg1 = (Dali::VectorBase *)jarg1;
20644   {
20645     try {
20646       result = ((Dali::VectorBase const *)arg1)->Capacity();
20647     } catch (std::out_of_range& e) {
20648       {
20649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20650       };
20651     } catch (std::exception& e) {
20652       {
20653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20654       };
20655     } catch (...) {
20656       {
20657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20658       };
20659     }
20660   }
20661   jresult = (unsigned long)result;
20662   return jresult;
20663 }
20664
20665
20666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20667   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20668
20669   arg1 = (Dali::VectorBase *)jarg1;
20670   {
20671     try {
20672       (arg1)->Release();
20673     } catch (std::out_of_range& e) {
20674       {
20675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20676       };
20677     } catch (std::exception& e) {
20678       {
20679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20680       };
20681     } catch (...) {
20682       {
20683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20684       };
20685     }
20686   }
20687 }
20688
20689
20690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20691   void * jresult ;
20692   Dali::Image *result = 0 ;
20693
20694   {
20695     try {
20696       result = (Dali::Image *)new Dali::Image();
20697     } catch (std::out_of_range& e) {
20698       {
20699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (std::exception& e) {
20702       {
20703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711   jresult = (void *)result;
20712   return jresult;
20713 }
20714
20715
20716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20717   Dali::Image *arg1 = (Dali::Image *) 0 ;
20718
20719   arg1 = (Dali::Image *)jarg1;
20720   {
20721     try {
20722       delete arg1;
20723     } catch (std::out_of_range& e) {
20724       {
20725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20726       };
20727     } catch (std::exception& e) {
20728       {
20729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20730       };
20731     } catch (...) {
20732       {
20733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20734       };
20735     }
20736   }
20737 }
20738
20739
20740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20741   void * jresult ;
20742   Dali::Image *arg1 = 0 ;
20743   Dali::Image *result = 0 ;
20744
20745   arg1 = (Dali::Image *)jarg1;
20746   if (!arg1) {
20747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20748     return 0;
20749   }
20750   {
20751     try {
20752       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20753     } catch (std::out_of_range& e) {
20754       {
20755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20756       };
20757     } catch (std::exception& e) {
20758       {
20759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20760       };
20761     } catch (...) {
20762       {
20763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20764       };
20765     }
20766   }
20767   jresult = (void *)result;
20768   return jresult;
20769 }
20770
20771
20772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20773   void * jresult ;
20774   Dali::Image *arg1 = (Dali::Image *) 0 ;
20775   Dali::Image *arg2 = 0 ;
20776   Dali::Image *result = 0 ;
20777
20778   arg1 = (Dali::Image *)jarg1;
20779   arg2 = (Dali::Image *)jarg2;
20780   if (!arg2) {
20781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20782     return 0;
20783   }
20784   {
20785     try {
20786       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20787     } catch (std::out_of_range& e) {
20788       {
20789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20790       };
20791     } catch (std::exception& e) {
20792       {
20793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20794       };
20795     } catch (...) {
20796       {
20797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20798       };
20799     }
20800   }
20801   jresult = (void *)result;
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20807   void * jresult ;
20808   Dali::BaseHandle arg1 ;
20809   Dali::BaseHandle *argp1 ;
20810   Dali::Image result;
20811
20812   argp1 = (Dali::BaseHandle *)jarg1;
20813   if (!argp1) {
20814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20815     return 0;
20816   }
20817   arg1 = *argp1;
20818   {
20819     try {
20820       result = Dali::Image::DownCast(arg1);
20821     } catch (std::out_of_range& e) {
20822       {
20823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20824       };
20825     } catch (std::exception& e) {
20826       {
20827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20828       };
20829     } catch (...) {
20830       {
20831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20832       };
20833     }
20834   }
20835   jresult = new Dali::Image((const Dali::Image &)result);
20836   return jresult;
20837 }
20838
20839
20840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20841   unsigned int jresult ;
20842   Dali::Image *arg1 = (Dali::Image *) 0 ;
20843   unsigned int result;
20844
20845   arg1 = (Dali::Image *)jarg1;
20846   {
20847     try {
20848       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20849     } catch (std::out_of_range& e) {
20850       {
20851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20852       };
20853     } catch (std::exception& e) {
20854       {
20855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20856       };
20857     } catch (...) {
20858       {
20859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20860       };
20861     }
20862   }
20863   jresult = result;
20864   return jresult;
20865 }
20866
20867
20868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20869   unsigned int jresult ;
20870   Dali::Image *arg1 = (Dali::Image *) 0 ;
20871   unsigned int result;
20872
20873   arg1 = (Dali::Image *)jarg1;
20874   {
20875     try {
20876       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20877     } catch (std::out_of_range& e) {
20878       {
20879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20880       };
20881     } catch (std::exception& e) {
20882       {
20883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20884       };
20885     } catch (...) {
20886       {
20887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20888       };
20889     }
20890   }
20891   jresult = result;
20892   return jresult;
20893 }
20894
20895
20896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20897   void * jresult ;
20898   Dali::Image *arg1 = (Dali::Image *) 0 ;
20899   Dali::Image::ImageSignalType *result = 0 ;
20900
20901   arg1 = (Dali::Image *)jarg1;
20902   {
20903     try {
20904       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20905     } catch (std::out_of_range& e) {
20906       {
20907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20908       };
20909     } catch (std::exception& e) {
20910       {
20911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20912       };
20913     } catch (...) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20916       };
20917     }
20918   }
20919   jresult = (void *)result;
20920   return jresult;
20921 }
20922
20923
20924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20925   int jresult ;
20926   Dali::Pixel::Format result;
20927
20928   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20929   jresult = (int)result;
20930   return jresult;
20931 }
20932
20933
20934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20935   int jresult ;
20936   Dali::Pixel::Format result;
20937
20938   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20939   jresult = (int)result;
20940   return jresult;
20941 }
20942
20943
20944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20945   unsigned int jresult ;
20946   Dali::Pixel::Format arg1 ;
20947   bool result;
20948
20949   arg1 = (Dali::Pixel::Format)jarg1;
20950   {
20951     try {
20952       result = (bool)Dali::Pixel::HasAlpha(arg1);
20953     } catch (std::out_of_range& e) {
20954       {
20955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20956       };
20957     } catch (std::exception& e) {
20958       {
20959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20960       };
20961     } catch (...) {
20962       {
20963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20964       };
20965     }
20966   }
20967   jresult = result;
20968   return jresult;
20969 }
20970
20971
20972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20973   unsigned int jresult ;
20974   Dali::Pixel::Format arg1 ;
20975   unsigned int result;
20976
20977   arg1 = (Dali::Pixel::Format)jarg1;
20978   {
20979     try {
20980       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
20981     } catch (std::out_of_range& e) {
20982       {
20983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20984       };
20985     } catch (std::exception& e) {
20986       {
20987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (...) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20992       };
20993     }
20994   }
20995   jresult = result;
20996   return jresult;
20997 }
20998
20999
21000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21001   Dali::Pixel::Format arg1 ;
21002   int *arg2 = 0 ;
21003   int *arg3 = 0 ;
21004
21005   arg1 = (Dali::Pixel::Format)jarg1;
21006   arg2 = (int *)jarg2;
21007   if (!arg2) {
21008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21009     return ;
21010   }
21011   arg3 = (int *)jarg3;
21012   if (!arg3) {
21013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21014     return ;
21015   }
21016   {
21017     try {
21018       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21019     } catch (std::out_of_range& e) {
21020       {
21021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21022       };
21023     } catch (std::exception& e) {
21024       {
21025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21026       };
21027     } catch (...) {
21028       {
21029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21030       };
21031     }
21032   }
21033 }
21034
21035
21036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21037   void * jresult ;
21038   unsigned char *arg1 = (unsigned char *) 0 ;
21039   unsigned int arg2 ;
21040   unsigned int arg3 ;
21041   unsigned int arg4 ;
21042   Dali::Pixel::Format arg5 ;
21043   Dali::PixelData::ReleaseFunction arg6 ;
21044   Dali::PixelData result;
21045
21046   arg1 = jarg1;
21047   arg2 = (unsigned int)jarg2;
21048   arg3 = (unsigned int)jarg3;
21049   arg4 = (unsigned int)jarg4;
21050   arg5 = (Dali::Pixel::Format)jarg5;
21051   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21052   {
21053     try {
21054       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (...) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21066       };
21067     }
21068   }
21069   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21070
21071
21072   return jresult;
21073 }
21074
21075
21076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21077   void * jresult ;
21078   Dali::PixelData *result = 0 ;
21079
21080   {
21081     try {
21082       result = (Dali::PixelData *)new Dali::PixelData();
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21094       };
21095     }
21096   }
21097   jresult = (void *)result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21103   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21104
21105   arg1 = (Dali::PixelData *)jarg1;
21106   {
21107     try {
21108       delete arg1;
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (...) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21120       };
21121     }
21122   }
21123 }
21124
21125
21126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21127   void * jresult ;
21128   Dali::PixelData *arg1 = 0 ;
21129   Dali::PixelData *result = 0 ;
21130
21131   arg1 = (Dali::PixelData *)jarg1;
21132   if (!arg1) {
21133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21134     return 0;
21135   }
21136   {
21137     try {
21138       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21139     } catch (std::out_of_range& e) {
21140       {
21141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21142       };
21143     } catch (std::exception& e) {
21144       {
21145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21146       };
21147     } catch (...) {
21148       {
21149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21150       };
21151     }
21152   }
21153   jresult = (void *)result;
21154   return jresult;
21155 }
21156
21157
21158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21159   void * jresult ;
21160   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21161   Dali::PixelData *arg2 = 0 ;
21162   Dali::PixelData *result = 0 ;
21163
21164   arg1 = (Dali::PixelData *)jarg1;
21165   arg2 = (Dali::PixelData *)jarg2;
21166   if (!arg2) {
21167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21168     return 0;
21169   }
21170   {
21171     try {
21172       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21173     } catch (std::out_of_range& e) {
21174       {
21175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21176       };
21177     } catch (std::exception& e) {
21178       {
21179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21180       };
21181     } catch (...) {
21182       {
21183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21184       };
21185     }
21186   }
21187   jresult = (void *)result;
21188   return jresult;
21189 }
21190
21191
21192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21193   unsigned int jresult ;
21194   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21195   unsigned int result;
21196
21197   arg1 = (Dali::PixelData *)jarg1;
21198   {
21199     try {
21200       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21201     } catch (std::out_of_range& e) {
21202       {
21203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21204       };
21205     } catch (std::exception& e) {
21206       {
21207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (...) {
21210       {
21211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21212       };
21213     }
21214   }
21215   jresult = result;
21216   return jresult;
21217 }
21218
21219
21220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21221   unsigned int jresult ;
21222   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21223   unsigned int result;
21224
21225   arg1 = (Dali::PixelData *)jarg1;
21226   {
21227     try {
21228       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21229     } catch (std::out_of_range& e) {
21230       {
21231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21232       };
21233     } catch (std::exception& e) {
21234       {
21235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21236       };
21237     } catch (...) {
21238       {
21239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21240       };
21241     }
21242   }
21243   jresult = result;
21244   return jresult;
21245 }
21246
21247
21248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21249   int jresult ;
21250   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21251   Dali::Pixel::Format result;
21252
21253   arg1 = (Dali::PixelData *)jarg1;
21254   {
21255     try {
21256       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21257     } catch (std::out_of_range& e) {
21258       {
21259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21260       };
21261     } catch (std::exception& e) {
21262       {
21263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21264       };
21265     } catch (...) {
21266       {
21267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21268       };
21269     }
21270   }
21271   jresult = (int)result;
21272   return jresult;
21273 }
21274
21275
21276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21277   unsigned int jresult ;
21278   unsigned int result;
21279
21280   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21281   jresult = result;
21282   return jresult;
21283 }
21284
21285
21286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21287   unsigned int jresult ;
21288   unsigned int result;
21289
21290   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21291   jresult = result;
21292   return jresult;
21293 }
21294
21295
21296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21297   unsigned int jresult ;
21298   unsigned int result;
21299
21300   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21301   jresult = result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21307   unsigned int jresult ;
21308   unsigned int result;
21309
21310   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21311   jresult = result;
21312   return jresult;
21313 }
21314
21315
21316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21317   unsigned int jresult ;
21318   unsigned int result;
21319
21320   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21321   jresult = result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21327   unsigned int jresult ;
21328   unsigned int result;
21329
21330   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21331   jresult = result;
21332   return jresult;
21333 }
21334
21335
21336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21337   void * jresult ;
21338   Dali::TextureType::Type arg1 ;
21339   Dali::Pixel::Format arg2 ;
21340   unsigned int arg3 ;
21341   unsigned int arg4 ;
21342   Dali::Texture result;
21343
21344   arg1 = (Dali::TextureType::Type)jarg1;
21345   arg2 = (Dali::Pixel::Format)jarg2;
21346   arg3 = (unsigned int)jarg3;
21347   arg4 = (unsigned int)jarg4;
21348   {
21349     try {
21350       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21351     } catch (std::out_of_range& e) {
21352       {
21353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21354       };
21355     } catch (std::exception& e) {
21356       {
21357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21358       };
21359     } catch (...) {
21360       {
21361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21362       };
21363     }
21364   }
21365   jresult = new Dali::Texture((const Dali::Texture &)result);
21366   return jresult;
21367 }
21368
21369
21370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21371   void * jresult ;
21372   NativeImageInterface *arg1 = 0 ;
21373   Dali::Texture result;
21374
21375   arg1 = (NativeImageInterface *)jarg1;
21376   if (!arg1) {
21377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21378     return 0;
21379   }
21380   {
21381     try {
21382       result = Dali::Texture::New(*arg1);
21383     } catch (std::out_of_range& e) {
21384       {
21385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21386       };
21387     } catch (std::exception& e) {
21388       {
21389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (...) {
21392       {
21393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21394       };
21395     }
21396   }
21397   jresult = new Dali::Texture((const Dali::Texture &)result);
21398   return jresult;
21399 }
21400
21401
21402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21403   void * jresult ;
21404   Dali::Texture *result = 0 ;
21405
21406   {
21407     try {
21408       result = (Dali::Texture *)new Dali::Texture();
21409     } catch (std::out_of_range& e) {
21410       {
21411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21412       };
21413     } catch (std::exception& e) {
21414       {
21415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21416       };
21417     } catch (...) {
21418       {
21419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21420       };
21421     }
21422   }
21423   jresult = (void *)result;
21424   return jresult;
21425 }
21426
21427
21428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21429   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21430
21431   arg1 = (Dali::Texture *)jarg1;
21432   {
21433     try {
21434       delete arg1;
21435     } catch (std::out_of_range& e) {
21436       {
21437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21438       };
21439     } catch (std::exception& e) {
21440       {
21441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21442       };
21443     } catch (...) {
21444       {
21445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21446       };
21447     }
21448   }
21449 }
21450
21451
21452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21453   void * jresult ;
21454   Dali::Texture *arg1 = 0 ;
21455   Dali::Texture *result = 0 ;
21456
21457   arg1 = (Dali::Texture *)jarg1;
21458   if (!arg1) {
21459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21460     return 0;
21461   }
21462   {
21463     try {
21464       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21465     } catch (std::out_of_range& e) {
21466       {
21467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (std::exception& e) {
21470       {
21471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21472       };
21473     } catch (...) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21476       };
21477     }
21478   }
21479   jresult = (void *)result;
21480   return jresult;
21481 }
21482
21483
21484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21485   void * jresult ;
21486   Dali::BaseHandle arg1 ;
21487   Dali::BaseHandle *argp1 ;
21488   Dali::Texture result;
21489
21490   argp1 = (Dali::BaseHandle *)jarg1;
21491   if (!argp1) {
21492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21493     return 0;
21494   }
21495   arg1 = *argp1;
21496   {
21497     try {
21498       result = Dali::Texture::DownCast(arg1);
21499     } catch (std::out_of_range& e) {
21500       {
21501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21502       };
21503     } catch (std::exception& e) {
21504       {
21505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21506       };
21507     } catch (...) {
21508       {
21509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21510       };
21511     }
21512   }
21513   jresult = new Dali::Texture((const Dali::Texture &)result);
21514   return jresult;
21515 }
21516
21517
21518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21519   void * jresult ;
21520   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21521   Dali::Texture *arg2 = 0 ;
21522   Dali::Texture *result = 0 ;
21523
21524   arg1 = (Dali::Texture *)jarg1;
21525   arg2 = (Dali::Texture *)jarg2;
21526   if (!arg2) {
21527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21528     return 0;
21529   }
21530   {
21531     try {
21532       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21533     } catch (std::out_of_range& e) {
21534       {
21535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21536       };
21537     } catch (std::exception& e) {
21538       {
21539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21540       };
21541     } catch (...) {
21542       {
21543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21544       };
21545     }
21546   }
21547   jresult = (void *)result;
21548   return jresult;
21549 }
21550
21551
21552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21553   unsigned int jresult ;
21554   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21555   Dali::PixelData arg2 ;
21556   Dali::PixelData *argp2 ;
21557   bool result;
21558
21559   arg1 = (Dali::Texture *)jarg1;
21560   argp2 = (Dali::PixelData *)jarg2;
21561   if (!argp2) {
21562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21563     return 0;
21564   }
21565   arg2 = *argp2;
21566   {
21567     try {
21568       result = (bool)(arg1)->Upload(arg2);
21569     } catch (std::out_of_range& e) {
21570       {
21571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21572       };
21573     } catch (std::exception& e) {
21574       {
21575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21576       };
21577     } catch (...) {
21578       {
21579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21580       };
21581     }
21582   }
21583   jresult = result;
21584   return jresult;
21585 }
21586
21587
21588 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) {
21589   unsigned int jresult ;
21590   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21591   Dali::PixelData arg2 ;
21592   unsigned int arg3 ;
21593   unsigned int arg4 ;
21594   unsigned int arg5 ;
21595   unsigned int arg6 ;
21596   unsigned int arg7 ;
21597   unsigned int arg8 ;
21598   Dali::PixelData *argp2 ;
21599   bool result;
21600
21601   arg1 = (Dali::Texture *)jarg1;
21602   argp2 = (Dali::PixelData *)jarg2;
21603   if (!argp2) {
21604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21605     return 0;
21606   }
21607   arg2 = *argp2;
21608   arg3 = (unsigned int)jarg3;
21609   arg4 = (unsigned int)jarg4;
21610   arg5 = (unsigned int)jarg5;
21611   arg6 = (unsigned int)jarg6;
21612   arg7 = (unsigned int)jarg7;
21613   arg8 = (unsigned int)jarg8;
21614   {
21615     try {
21616       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21617     } catch (std::out_of_range& e) {
21618       {
21619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21620       };
21621     } catch (std::exception& e) {
21622       {
21623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21624       };
21625     } catch (...) {
21626       {
21627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21628       };
21629     }
21630   }
21631   jresult = result;
21632   return jresult;
21633 }
21634
21635
21636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21637   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21638
21639   arg1 = (Dali::Texture *)jarg1;
21640   {
21641     try {
21642       (arg1)->GenerateMipmaps();
21643     } catch (std::out_of_range& e) {
21644       {
21645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21646       };
21647     } catch (std::exception& e) {
21648       {
21649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21650       };
21651     } catch (...) {
21652       {
21653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21654       };
21655     }
21656   }
21657 }
21658
21659
21660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21661   unsigned int jresult ;
21662   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21663   unsigned int result;
21664
21665   arg1 = (Dali::Texture *)jarg1;
21666   {
21667     try {
21668       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21669     } catch (std::out_of_range& e) {
21670       {
21671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21672       };
21673     } catch (std::exception& e) {
21674       {
21675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21676       };
21677     } catch (...) {
21678       {
21679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21680       };
21681     }
21682   }
21683   jresult = result;
21684   return jresult;
21685 }
21686
21687
21688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21689   unsigned int jresult ;
21690   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21691   unsigned int result;
21692
21693   arg1 = (Dali::Texture *)jarg1;
21694   {
21695     try {
21696       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21697     } catch (std::out_of_range& e) {
21698       {
21699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21700       };
21701     } catch (std::exception& e) {
21702       {
21703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21704       };
21705     } catch (...) {
21706       {
21707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21708       };
21709     }
21710   }
21711   jresult = result;
21712   return jresult;
21713 }
21714
21715
21716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21717   void * jresult ;
21718   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21719   Dali::Texture *result = 0 ;
21720
21721   arg1 = (Dali::Internal::Texture *)jarg1;
21722   {
21723     try {
21724       result = (Dali::Texture *)new Dali::Texture(arg1);
21725     } catch (std::out_of_range& e) {
21726       {
21727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21728       };
21729     } catch (std::exception& e) {
21730       {
21731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21736       };
21737     }
21738   }
21739   jresult = (void *)result;
21740   return jresult;
21741 }
21742
21743
21744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21745   void * jresult ;
21746   Dali::Sampler result;
21747
21748   {
21749     try {
21750       result = Dali::Sampler::New();
21751     } catch (std::out_of_range& e) {
21752       {
21753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (std::exception& e) {
21756       {
21757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (...) {
21760       {
21761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21762       };
21763     }
21764   }
21765   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21766   return jresult;
21767 }
21768
21769
21770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21771   void * jresult ;
21772   Dali::Sampler *result = 0 ;
21773
21774   {
21775     try {
21776       result = (Dali::Sampler *)new Dali::Sampler();
21777     } catch (std::out_of_range& e) {
21778       {
21779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21780       };
21781     } catch (std::exception& e) {
21782       {
21783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21784       };
21785     } catch (...) {
21786       {
21787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21788       };
21789     }
21790   }
21791   jresult = (void *)result;
21792   return jresult;
21793 }
21794
21795
21796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21797   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21798
21799   arg1 = (Dali::Sampler *)jarg1;
21800   {
21801     try {
21802       delete arg1;
21803     } catch (std::out_of_range& e) {
21804       {
21805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21806       };
21807     } catch (std::exception& e) {
21808       {
21809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21810       };
21811     } catch (...) {
21812       {
21813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21814       };
21815     }
21816   }
21817 }
21818
21819
21820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21821   void * jresult ;
21822   Dali::Sampler *arg1 = 0 ;
21823   Dali::Sampler *result = 0 ;
21824
21825   arg1 = (Dali::Sampler *)jarg1;
21826   if (!arg1) {
21827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21828     return 0;
21829   }
21830   {
21831     try {
21832       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847   jresult = (void *)result;
21848   return jresult;
21849 }
21850
21851
21852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21853   void * jresult ;
21854   Dali::BaseHandle arg1 ;
21855   Dali::BaseHandle *argp1 ;
21856   Dali::Sampler result;
21857
21858   argp1 = (Dali::BaseHandle *)jarg1;
21859   if (!argp1) {
21860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21861     return 0;
21862   }
21863   arg1 = *argp1;
21864   {
21865     try {
21866       result = Dali::Sampler::DownCast(arg1);
21867     } catch (std::out_of_range& e) {
21868       {
21869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21870       };
21871     } catch (std::exception& e) {
21872       {
21873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21874       };
21875     } catch (...) {
21876       {
21877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21878       };
21879     }
21880   }
21881   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21882   return jresult;
21883 }
21884
21885
21886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21887   void * jresult ;
21888   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21889   Dali::Sampler *arg2 = 0 ;
21890   Dali::Sampler *result = 0 ;
21891
21892   arg1 = (Dali::Sampler *)jarg1;
21893   arg2 = (Dali::Sampler *)jarg2;
21894   if (!arg2) {
21895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21896     return 0;
21897   }
21898   {
21899     try {
21900       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21901     } catch (std::out_of_range& e) {
21902       {
21903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21904       };
21905     } catch (std::exception& e) {
21906       {
21907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21908       };
21909     } catch (...) {
21910       {
21911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21912       };
21913     }
21914   }
21915   jresult = (void *)result;
21916   return jresult;
21917 }
21918
21919
21920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21921   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21922   Dali::FilterMode::Type arg2 ;
21923   Dali::FilterMode::Type arg3 ;
21924
21925   arg1 = (Dali::Sampler *)jarg1;
21926   arg2 = (Dali::FilterMode::Type)jarg2;
21927   arg3 = (Dali::FilterMode::Type)jarg3;
21928   {
21929     try {
21930       (arg1)->SetFilterMode(arg2,arg3);
21931     } catch (std::out_of_range& e) {
21932       {
21933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21934       };
21935     } catch (std::exception& e) {
21936       {
21937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21938       };
21939     } catch (...) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21942       };
21943     }
21944   }
21945 }
21946
21947
21948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21949   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21950   Dali::WrapMode::Type arg2 ;
21951   Dali::WrapMode::Type arg3 ;
21952
21953   arg1 = (Dali::Sampler *)jarg1;
21954   arg2 = (Dali::WrapMode::Type)jarg2;
21955   arg3 = (Dali::WrapMode::Type)jarg3;
21956   {
21957     try {
21958       (arg1)->SetWrapMode(arg2,arg3);
21959     } catch (std::out_of_range& e) {
21960       {
21961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21962       };
21963     } catch (std::exception& e) {
21964       {
21965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21966       };
21967     } catch (...) {
21968       {
21969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21970       };
21971     }
21972   }
21973 }
21974
21975
21976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21977   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21978   Dali::WrapMode::Type arg2 ;
21979   Dali::WrapMode::Type arg3 ;
21980   Dali::WrapMode::Type arg4 ;
21981
21982   arg1 = (Dali::Sampler *)jarg1;
21983   arg2 = (Dali::WrapMode::Type)jarg2;
21984   arg3 = (Dali::WrapMode::Type)jarg3;
21985   arg4 = (Dali::WrapMode::Type)jarg4;
21986   {
21987     try {
21988       (arg1)->SetWrapMode(arg2,arg3,arg4);
21989     } catch (std::out_of_range& e) {
21990       {
21991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21992       };
21993     } catch (std::exception& e) {
21994       {
21995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21996       };
21997     } catch (...) {
21998       {
21999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22000       };
22001     }
22002   }
22003 }
22004
22005
22006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22007   void * jresult ;
22008   Dali::TextureSet result;
22009
22010   {
22011     try {
22012       result = Dali::TextureSet::New();
22013     } catch (std::out_of_range& e) {
22014       {
22015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22016       };
22017     } catch (std::exception& e) {
22018       {
22019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22024       };
22025     }
22026   }
22027   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22028   return jresult;
22029 }
22030
22031
22032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22033   void * jresult ;
22034   Dali::TextureSet *result = 0 ;
22035
22036   {
22037     try {
22038       result = (Dali::TextureSet *)new Dali::TextureSet();
22039     } catch (std::out_of_range& e) {
22040       {
22041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22042       };
22043     } catch (std::exception& e) {
22044       {
22045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22046       };
22047     } catch (...) {
22048       {
22049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22050       };
22051     }
22052   }
22053   jresult = (void *)result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22059   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22060
22061   arg1 = (Dali::TextureSet *)jarg1;
22062   {
22063     try {
22064       delete arg1;
22065     } catch (std::out_of_range& e) {
22066       {
22067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22068       };
22069     } catch (std::exception& e) {
22070       {
22071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22072       };
22073     } catch (...) {
22074       {
22075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22076       };
22077     }
22078   }
22079 }
22080
22081
22082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22083   void * jresult ;
22084   Dali::TextureSet *arg1 = 0 ;
22085   Dali::TextureSet *result = 0 ;
22086
22087   arg1 = (Dali::TextureSet *)jarg1;
22088   if (!arg1) {
22089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22090     return 0;
22091   }
22092   {
22093     try {
22094       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22095     } catch (std::out_of_range& e) {
22096       {
22097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (std::exception& e) {
22100       {
22101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22102       };
22103     } catch (...) {
22104       {
22105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22106       };
22107     }
22108   }
22109   jresult = (void *)result;
22110   return jresult;
22111 }
22112
22113
22114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22115   void * jresult ;
22116   Dali::BaseHandle arg1 ;
22117   Dali::BaseHandle *argp1 ;
22118   Dali::TextureSet result;
22119
22120   argp1 = (Dali::BaseHandle *)jarg1;
22121   if (!argp1) {
22122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22123     return 0;
22124   }
22125   arg1 = *argp1;
22126   {
22127     try {
22128       result = Dali::TextureSet::DownCast(arg1);
22129     } catch (std::out_of_range& e) {
22130       {
22131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22132       };
22133     } catch (std::exception& e) {
22134       {
22135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22136       };
22137     } catch (...) {
22138       {
22139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22140       };
22141     }
22142   }
22143   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22144   return jresult;
22145 }
22146
22147
22148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22149   void * jresult ;
22150   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22151   Dali::TextureSet *arg2 = 0 ;
22152   Dali::TextureSet *result = 0 ;
22153
22154   arg1 = (Dali::TextureSet *)jarg1;
22155   arg2 = (Dali::TextureSet *)jarg2;
22156   if (!arg2) {
22157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22158     return 0;
22159   }
22160   {
22161     try {
22162       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22163     } catch (std::out_of_range& e) {
22164       {
22165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22166       };
22167     } catch (std::exception& e) {
22168       {
22169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22170       };
22171     } catch (...) {
22172       {
22173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22174       };
22175     }
22176   }
22177   jresult = (void *)result;
22178   return jresult;
22179 }
22180
22181
22182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22183   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22184   size_t arg2 ;
22185   Dali::Texture arg3 ;
22186   Dali::Texture *argp3 ;
22187
22188   arg1 = (Dali::TextureSet *)jarg1;
22189   arg2 = (size_t)jarg2;
22190   argp3 = (Dali::Texture *)jarg3;
22191   if (!argp3) {
22192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22193     return ;
22194   }
22195   arg3 = *argp3;
22196   {
22197     try {
22198       (arg1)->SetTexture(arg2,arg3);
22199     } catch (std::out_of_range& e) {
22200       {
22201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22202       };
22203     } catch (std::exception& e) {
22204       {
22205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22206       };
22207     } catch (...) {
22208       {
22209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22210       };
22211     }
22212   }
22213 }
22214
22215
22216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22217   void * jresult ;
22218   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22219   size_t arg2 ;
22220   Dali::Texture result;
22221
22222   arg1 = (Dali::TextureSet *)jarg1;
22223   arg2 = (size_t)jarg2;
22224   {
22225     try {
22226       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22227     } catch (std::out_of_range& e) {
22228       {
22229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22230       };
22231     } catch (std::exception& e) {
22232       {
22233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22234       };
22235     } catch (...) {
22236       {
22237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22238       };
22239     }
22240   }
22241   jresult = new Dali::Texture((const Dali::Texture &)result);
22242   return jresult;
22243 }
22244
22245
22246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22247   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22248   size_t arg2 ;
22249   Dali::Sampler arg3 ;
22250   Dali::Sampler *argp3 ;
22251
22252   arg1 = (Dali::TextureSet *)jarg1;
22253   arg2 = (size_t)jarg2;
22254   argp3 = (Dali::Sampler *)jarg3;
22255   if (!argp3) {
22256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22257     return ;
22258   }
22259   arg3 = *argp3;
22260   {
22261     try {
22262       (arg1)->SetSampler(arg2,arg3);
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22270       };
22271     } catch (...) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22274       };
22275     }
22276   }
22277 }
22278
22279
22280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22281   void * jresult ;
22282   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22283   size_t arg2 ;
22284   Dali::Sampler result;
22285
22286   arg1 = (Dali::TextureSet *)jarg1;
22287   arg2 = (size_t)jarg2;
22288   {
22289     try {
22290       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22291     } catch (std::out_of_range& e) {
22292       {
22293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22294       };
22295     } catch (std::exception& e) {
22296       {
22297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22298       };
22299     } catch (...) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22302       };
22303     }
22304   }
22305   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22306   return jresult;
22307 }
22308
22309
22310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22311   unsigned long jresult ;
22312   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22313   size_t result;
22314
22315   arg1 = (Dali::TextureSet *)jarg1;
22316   {
22317     try {
22318       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22319     } catch (std::out_of_range& e) {
22320       {
22321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22322       };
22323     } catch (std::exception& e) {
22324       {
22325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22326       };
22327     } catch (...) {
22328       {
22329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22330       };
22331     }
22332   }
22333   jresult = (unsigned long)result;
22334   return jresult;
22335 }
22336
22337
22338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22339   void * jresult ;
22340   Dali::Property::Map *arg1 = 0 ;
22341   Dali::PropertyBuffer result;
22342
22343   arg1 = (Dali::Property::Map *)jarg1;
22344   if (!arg1) {
22345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22346     return 0;
22347   }
22348   {
22349     try {
22350       result = Dali::PropertyBuffer::New(*arg1);
22351     } catch (std::out_of_range& e) {
22352       {
22353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22354       };
22355     } catch (std::exception& e) {
22356       {
22357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22358       };
22359     } catch (...) {
22360       {
22361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22362       };
22363     }
22364   }
22365   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22366   return jresult;
22367 }
22368
22369
22370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22371   void * jresult ;
22372   Dali::PropertyBuffer *result = 0 ;
22373
22374   {
22375     try {
22376       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22377     } catch (std::out_of_range& e) {
22378       {
22379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22380       };
22381     } catch (std::exception& e) {
22382       {
22383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22384       };
22385     } catch (...) {
22386       {
22387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22388       };
22389     }
22390   }
22391   jresult = (void *)result;
22392   return jresult;
22393 }
22394
22395
22396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22397   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22398
22399   arg1 = (Dali::PropertyBuffer *)jarg1;
22400   {
22401     try {
22402       delete arg1;
22403     } catch (std::out_of_range& e) {
22404       {
22405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22406       };
22407     } catch (std::exception& e) {
22408       {
22409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22410       };
22411     } catch (...) {
22412       {
22413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22414       };
22415     }
22416   }
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22421   void * jresult ;
22422   Dali::PropertyBuffer *arg1 = 0 ;
22423   Dali::PropertyBuffer *result = 0 ;
22424
22425   arg1 = (Dali::PropertyBuffer *)jarg1;
22426   if (!arg1) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22428     return 0;
22429   }
22430   {
22431     try {
22432       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22433     } catch (std::out_of_range& e) {
22434       {
22435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22436       };
22437     } catch (std::exception& e) {
22438       {
22439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22440       };
22441     } catch (...) {
22442       {
22443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22444       };
22445     }
22446   }
22447   jresult = (void *)result;
22448   return jresult;
22449 }
22450
22451
22452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22453   void * jresult ;
22454   Dali::BaseHandle arg1 ;
22455   Dali::BaseHandle *argp1 ;
22456   Dali::PropertyBuffer result;
22457
22458   argp1 = (Dali::BaseHandle *)jarg1;
22459   if (!argp1) {
22460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22461     return 0;
22462   }
22463   arg1 = *argp1;
22464   {
22465     try {
22466       result = Dali::PropertyBuffer::DownCast(arg1);
22467     } catch (std::out_of_range& e) {
22468       {
22469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22470       };
22471     } catch (std::exception& e) {
22472       {
22473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22474       };
22475     } catch (...) {
22476       {
22477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22478       };
22479     }
22480   }
22481   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22482   return jresult;
22483 }
22484
22485
22486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22487   void * jresult ;
22488   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22489   Dali::PropertyBuffer *arg2 = 0 ;
22490   Dali::PropertyBuffer *result = 0 ;
22491
22492   arg1 = (Dali::PropertyBuffer *)jarg1;
22493   arg2 = (Dali::PropertyBuffer *)jarg2;
22494   if (!arg2) {
22495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22496     return 0;
22497   }
22498   {
22499     try {
22500       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22501     } catch (std::out_of_range& e) {
22502       {
22503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22504       };
22505     } catch (std::exception& e) {
22506       {
22507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22508       };
22509     } catch (...) {
22510       {
22511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22512       };
22513     }
22514   }
22515   jresult = (void *)result;
22516   return jresult;
22517 }
22518
22519
22520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22521   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22522   void *arg2 = (void *) 0 ;
22523   std::size_t arg3 ;
22524
22525   arg1 = (Dali::PropertyBuffer *)jarg1;
22526   arg2 = jarg2;
22527   arg3 = (std::size_t)jarg3;
22528   {
22529     try {
22530       (arg1)->SetData((void const *)arg2,arg3);
22531     } catch (std::out_of_range& e) {
22532       {
22533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22534       };
22535     } catch (std::exception& e) {
22536       {
22537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22542       };
22543     }
22544   }
22545 }
22546
22547
22548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22549   unsigned long jresult ;
22550   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22551   std::size_t result;
22552
22553   arg1 = (Dali::PropertyBuffer *)jarg1;
22554   {
22555     try {
22556       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22557     } catch (std::out_of_range& e) {
22558       {
22559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22560       };
22561     } catch (std::exception& e) {
22562       {
22563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22564       };
22565     } catch (...) {
22566       {
22567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22568       };
22569     }
22570   }
22571   jresult = (unsigned long)result;
22572   return jresult;
22573 }
22574
22575
22576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22577   void * jresult ;
22578   Dali::Geometry result;
22579
22580   {
22581     try {
22582       result = Dali::Geometry::New();
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (...) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22594       };
22595     }
22596   }
22597   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22598   return jresult;
22599 }
22600
22601
22602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22603   void * jresult ;
22604   Dali::Geometry *result = 0 ;
22605
22606   {
22607     try {
22608       result = (Dali::Geometry *)new Dali::Geometry();
22609     } catch (std::out_of_range& e) {
22610       {
22611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22612       };
22613     } catch (std::exception& e) {
22614       {
22615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22616       };
22617     } catch (...) {
22618       {
22619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22620       };
22621     }
22622   }
22623   jresult = (void *)result;
22624   return jresult;
22625 }
22626
22627
22628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22629   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22630
22631   arg1 = (Dali::Geometry *)jarg1;
22632   {
22633     try {
22634       delete arg1;
22635     } catch (std::out_of_range& e) {
22636       {
22637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22638       };
22639     } catch (std::exception& e) {
22640       {
22641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22642       };
22643     } catch (...) {
22644       {
22645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22646       };
22647     }
22648   }
22649 }
22650
22651
22652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22653   void * jresult ;
22654   Dali::Geometry *arg1 = 0 ;
22655   Dali::Geometry *result = 0 ;
22656
22657   arg1 = (Dali::Geometry *)jarg1;
22658   if (!arg1) {
22659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22660     return 0;
22661   }
22662   {
22663     try {
22664       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (...) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22676       };
22677     }
22678   }
22679   jresult = (void *)result;
22680   return jresult;
22681 }
22682
22683
22684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22685   void * jresult ;
22686   Dali::BaseHandle arg1 ;
22687   Dali::BaseHandle *argp1 ;
22688   Dali::Geometry result;
22689
22690   argp1 = (Dali::BaseHandle *)jarg1;
22691   if (!argp1) {
22692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22693     return 0;
22694   }
22695   arg1 = *argp1;
22696   {
22697     try {
22698       result = Dali::Geometry::DownCast(arg1);
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22706       };
22707     } catch (...) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22710       };
22711     }
22712   }
22713   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22714   return jresult;
22715 }
22716
22717
22718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22719   void * jresult ;
22720   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22721   Dali::Geometry *arg2 = 0 ;
22722   Dali::Geometry *result = 0 ;
22723
22724   arg1 = (Dali::Geometry *)jarg1;
22725   arg2 = (Dali::Geometry *)jarg2;
22726   if (!arg2) {
22727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22728     return 0;
22729   }
22730   {
22731     try {
22732       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22733     } catch (std::out_of_range& e) {
22734       {
22735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22736       };
22737     } catch (std::exception& e) {
22738       {
22739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22740       };
22741     } catch (...) {
22742       {
22743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22744       };
22745     }
22746   }
22747   jresult = (void *)result;
22748   return jresult;
22749 }
22750
22751
22752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22753   unsigned long jresult ;
22754   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22755   Dali::PropertyBuffer *arg2 = 0 ;
22756   std::size_t result;
22757
22758   arg1 = (Dali::Geometry *)jarg1;
22759   arg2 = (Dali::PropertyBuffer *)jarg2;
22760   if (!arg2) {
22761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22762     return 0;
22763   }
22764   {
22765     try {
22766       result = (arg1)->AddVertexBuffer(*arg2);
22767     } catch (std::out_of_range& e) {
22768       {
22769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (std::exception& e) {
22772       {
22773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22774       };
22775     } catch (...) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22778       };
22779     }
22780   }
22781   jresult = (unsigned long)result;
22782   return jresult;
22783 }
22784
22785
22786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22787   unsigned long jresult ;
22788   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22789   std::size_t result;
22790
22791   arg1 = (Dali::Geometry *)jarg1;
22792   {
22793     try {
22794       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22795     } catch (std::out_of_range& e) {
22796       {
22797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22798       };
22799     } catch (std::exception& e) {
22800       {
22801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22802       };
22803     } catch (...) {
22804       {
22805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22806       };
22807     }
22808   }
22809   jresult = (unsigned long)result;
22810   return jresult;
22811 }
22812
22813
22814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22815   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22816   std::size_t arg2 ;
22817
22818   arg1 = (Dali::Geometry *)jarg1;
22819   arg2 = (std::size_t)jarg2;
22820   {
22821     try {
22822       (arg1)->RemoveVertexBuffer(arg2);
22823     } catch (std::out_of_range& e) {
22824       {
22825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22826       };
22827     } catch (std::exception& e) {
22828       {
22829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22830       };
22831     } catch (...) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22834       };
22835     }
22836   }
22837 }
22838
22839
22840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22841   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22842   unsigned short *arg2 = (unsigned short *) 0 ;
22843   size_t arg3 ;
22844
22845   arg1 = (Dali::Geometry *)jarg1;
22846   arg2 = jarg2;
22847   arg3 = (size_t)jarg3;
22848   {
22849     try {
22850       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22851     } catch (std::out_of_range& e) {
22852       {
22853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22854       };
22855     } catch (std::exception& e) {
22856       {
22857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22858       };
22859     } catch (...) {
22860       {
22861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22862       };
22863     }
22864   }
22865
22866
22867 }
22868
22869
22870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22871   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22872   Dali::Geometry::Type arg2 ;
22873
22874   arg1 = (Dali::Geometry *)jarg1;
22875   arg2 = (Dali::Geometry::Type)jarg2;
22876   {
22877     try {
22878       (arg1)->SetType(arg2);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22886       };
22887     } catch (...) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22890       };
22891     }
22892   }
22893 }
22894
22895
22896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22897   int jresult ;
22898   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22899   Dali::Geometry::Type result;
22900
22901   arg1 = (Dali::Geometry *)jarg1;
22902   {
22903     try {
22904       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22905     } catch (std::out_of_range& e) {
22906       {
22907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22908       };
22909     } catch (std::exception& e) {
22910       {
22911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22912       };
22913     } catch (...) {
22914       {
22915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22916       };
22917     }
22918   }
22919   jresult = (int)result;
22920   return jresult;
22921 }
22922
22923
22924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22925   void * jresult ;
22926   Dali::Shader::Hint *result = 0 ;
22927
22928   {
22929     try {
22930       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22931     } catch (std::out_of_range& e) {
22932       {
22933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22934       };
22935     } catch (std::exception& e) {
22936       {
22937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22938       };
22939     } catch (...) {
22940       {
22941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22942       };
22943     }
22944   }
22945   jresult = (void *)result;
22946   return jresult;
22947 }
22948
22949
22950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22951   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22952
22953   arg1 = (Dali::Shader::Hint *)jarg1;
22954   {
22955     try {
22956       delete arg1;
22957     } catch (std::out_of_range& e) {
22958       {
22959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22960       };
22961     } catch (std::exception& e) {
22962       {
22963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22964       };
22965     } catch (...) {
22966       {
22967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22968       };
22969     }
22970   }
22971 }
22972
22973
22974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22975   int jresult ;
22976   int result;
22977
22978   result = (int)Dali::Shader::Property::PROGRAM;
22979   jresult = (int)result;
22980   return jresult;
22981 }
22982
22983
22984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
22985   void * jresult ;
22986   Dali::Shader::Property *result = 0 ;
22987
22988   {
22989     try {
22990       result = (Dali::Shader::Property *)new Dali::Shader::Property();
22991     } catch (std::out_of_range& e) {
22992       {
22993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22994       };
22995     } catch (std::exception& e) {
22996       {
22997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22998       };
22999     } catch (...) {
23000       {
23001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23002       };
23003     }
23004   }
23005   jresult = (void *)result;
23006   return jresult;
23007 }
23008
23009
23010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23011   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23012
23013   arg1 = (Dali::Shader::Property *)jarg1;
23014   {
23015     try {
23016       delete arg1;
23017     } catch (std::out_of_range& e) {
23018       {
23019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23020       };
23021     } catch (std::exception& e) {
23022       {
23023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23024       };
23025     } catch (...) {
23026       {
23027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23028       };
23029     }
23030   }
23031 }
23032
23033
23034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23035   void * jresult ;
23036   std::string *arg1 = 0 ;
23037   std::string *arg2 = 0 ;
23038   Dali::Shader::Hint::Value arg3 ;
23039   Dali::Shader result;
23040
23041   if (!jarg1) {
23042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23043     return 0;
23044   }
23045   std::string arg1_str(jarg1);
23046   arg1 = &arg1_str;
23047   if (!jarg2) {
23048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23049     return 0;
23050   }
23051   std::string arg2_str(jarg2);
23052   arg2 = &arg2_str;
23053   arg3 = (Dali::Shader::Hint::Value)jarg3;
23054   {
23055     try {
23056       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23057     } catch (std::out_of_range& e) {
23058       {
23059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23060       };
23061     } catch (std::exception& e) {
23062       {
23063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23064       };
23065     } catch (...) {
23066       {
23067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23068       };
23069     }
23070   }
23071   jresult = new Dali::Shader((const Dali::Shader &)result);
23072
23073   //argout typemap for const std::string&
23074
23075
23076   //argout typemap for const std::string&
23077
23078   return jresult;
23079 }
23080
23081
23082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23083   void * jresult ;
23084   std::string *arg1 = 0 ;
23085   std::string *arg2 = 0 ;
23086   Dali::Shader result;
23087
23088   if (!jarg1) {
23089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23090     return 0;
23091   }
23092   std::string arg1_str(jarg1);
23093   arg1 = &arg1_str;
23094   if (!jarg2) {
23095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23096     return 0;
23097   }
23098   std::string arg2_str(jarg2);
23099   arg2 = &arg2_str;
23100   {
23101     try {
23102       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23103     } catch (std::out_of_range& e) {
23104       {
23105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23106       };
23107     } catch (std::exception& e) {
23108       {
23109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23110       };
23111     } catch (...) {
23112       {
23113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23114       };
23115     }
23116   }
23117   jresult = new Dali::Shader((const Dali::Shader &)result);
23118
23119   //argout typemap for const std::string&
23120
23121
23122   //argout typemap for const std::string&
23123
23124   return jresult;
23125 }
23126
23127
23128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23129   void * jresult ;
23130   Dali::Shader *result = 0 ;
23131
23132   {
23133     try {
23134       result = (Dali::Shader *)new Dali::Shader();
23135     } catch (std::out_of_range& e) {
23136       {
23137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23138       };
23139     } catch (std::exception& e) {
23140       {
23141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23142       };
23143     } catch (...) {
23144       {
23145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23146       };
23147     }
23148   }
23149   jresult = (void *)result;
23150   return jresult;
23151 }
23152
23153
23154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23155   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23156
23157   arg1 = (Dali::Shader *)jarg1;
23158   {
23159     try {
23160       delete arg1;
23161     } catch (std::out_of_range& e) {
23162       {
23163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23164       };
23165     } catch (std::exception& e) {
23166       {
23167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23168       };
23169     } catch (...) {
23170       {
23171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23172       };
23173     }
23174   }
23175 }
23176
23177
23178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23179   void * jresult ;
23180   Dali::Shader *arg1 = 0 ;
23181   Dali::Shader *result = 0 ;
23182
23183   arg1 = (Dali::Shader *)jarg1;
23184   if (!arg1) {
23185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23186     return 0;
23187   }
23188   {
23189     try {
23190       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23191     } catch (std::out_of_range& e) {
23192       {
23193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23194       };
23195     } catch (std::exception& e) {
23196       {
23197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23198       };
23199     } catch (...) {
23200       {
23201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23202       };
23203     }
23204   }
23205   jresult = (void *)result;
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23211   void * jresult ;
23212   Dali::BaseHandle arg1 ;
23213   Dali::BaseHandle *argp1 ;
23214   Dali::Shader result;
23215
23216   argp1 = (Dali::BaseHandle *)jarg1;
23217   if (!argp1) {
23218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23219     return 0;
23220   }
23221   arg1 = *argp1;
23222   {
23223     try {
23224       result = Dali::Shader::DownCast(arg1);
23225     } catch (std::out_of_range& e) {
23226       {
23227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23228       };
23229     } catch (std::exception& e) {
23230       {
23231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23232       };
23233     } catch (...) {
23234       {
23235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23236       };
23237     }
23238   }
23239   jresult = new Dali::Shader((const Dali::Shader &)result);
23240   return jresult;
23241 }
23242
23243
23244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23245   void * jresult ;
23246   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23247   Dali::Shader *arg2 = 0 ;
23248   Dali::Shader *result = 0 ;
23249
23250   arg1 = (Dali::Shader *)jarg1;
23251   arg2 = (Dali::Shader *)jarg2;
23252   if (!arg2) {
23253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23254     return 0;
23255   }
23256   {
23257     try {
23258       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23259     } catch (std::out_of_range& e) {
23260       {
23261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23262       };
23263     } catch (std::exception& e) {
23264       {
23265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23266       };
23267     } catch (...) {
23268       {
23269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23270       };
23271     }
23272   }
23273   jresult = (void *)result;
23274   return jresult;
23275 }
23276
23277
23278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23279   int jresult ;
23280   int result;
23281
23282   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23283   jresult = (int)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23289   int jresult ;
23290   int result;
23291
23292   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23293   jresult = (int)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23299   int jresult ;
23300   int result;
23301
23302   result = (int)Dali::Renderer::Property::BLEND_MODE;
23303   jresult = (int)result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23309   int jresult ;
23310   int result;
23311
23312   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23313   jresult = (int)result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23319   int jresult ;
23320   int result;
23321
23322   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23323   jresult = (int)result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23329   int jresult ;
23330   int result;
23331
23332   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23333   jresult = (int)result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23339   int jresult ;
23340   int result;
23341
23342   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23343   jresult = (int)result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23349   int jresult ;
23350   int result;
23351
23352   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23353   jresult = (int)result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23359   int jresult ;
23360   int result;
23361
23362   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23363   jresult = (int)result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23369   int jresult ;
23370   int result;
23371
23372   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23373   jresult = (int)result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23379   int jresult ;
23380   int result;
23381
23382   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23383   jresult = (int)result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23389   int jresult ;
23390   int result;
23391
23392   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23399   int jresult ;
23400   int result;
23401
23402   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23403   jresult = (int)result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23409   int jresult ;
23410   int result;
23411
23412   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23413   jresult = (int)result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23419   int jresult ;
23420   int result;
23421
23422   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23423   jresult = (int)result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23429   int jresult ;
23430   int result;
23431
23432   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23433   jresult = (int)result;
23434   return jresult;
23435 }
23436
23437
23438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23439   int jresult ;
23440   int result;
23441
23442   result = (int)Dali::Renderer::Property::RENDER_MODE;
23443   jresult = (int)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23449   int jresult ;
23450   int result;
23451
23452   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23453   jresult = (int)result;
23454   return jresult;
23455 }
23456
23457
23458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23459   int jresult ;
23460   int result;
23461
23462   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23463   jresult = (int)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23469   int jresult ;
23470   int result;
23471
23472   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23473   jresult = (int)result;
23474   return jresult;
23475 }
23476
23477
23478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23479   int jresult ;
23480   int result;
23481
23482   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23483   jresult = (int)result;
23484   return jresult;
23485 }
23486
23487
23488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23489   int jresult ;
23490   int result;
23491
23492   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23493   jresult = (int)result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23499   int jresult ;
23500   int result;
23501
23502   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23503   jresult = (int)result;
23504   return jresult;
23505 }
23506
23507
23508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23509   int jresult ;
23510   int result;
23511
23512   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23513   jresult = (int)result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23519   void * jresult ;
23520   Dali::Renderer::Property *result = 0 ;
23521
23522   {
23523     try {
23524       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23525     } catch (std::out_of_range& e) {
23526       {
23527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23528       };
23529     } catch (std::exception& e) {
23530       {
23531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23532       };
23533     } catch (...) {
23534       {
23535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23536       };
23537     }
23538   }
23539   jresult = (void *)result;
23540   return jresult;
23541 }
23542
23543
23544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23545   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23546
23547   arg1 = (Dali::Renderer::Property *)jarg1;
23548   {
23549     try {
23550       delete arg1;
23551     } catch (std::out_of_range& e) {
23552       {
23553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23554       };
23555     } catch (std::exception& e) {
23556       {
23557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23558       };
23559     } catch (...) {
23560       {
23561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23562       };
23563     }
23564   }
23565 }
23566
23567
23568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23569   void * jresult ;
23570   Dali::Geometry *arg1 = 0 ;
23571   Dali::Shader *arg2 = 0 ;
23572   Dali::Renderer result;
23573
23574   arg1 = (Dali::Geometry *)jarg1;
23575   if (!arg1) {
23576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23577     return 0;
23578   }
23579   arg2 = (Dali::Shader *)jarg2;
23580   if (!arg2) {
23581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23582     return 0;
23583   }
23584   {
23585     try {
23586       result = Dali::Renderer::New(*arg1,*arg2);
23587     } catch (std::out_of_range& e) {
23588       {
23589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23590       };
23591     } catch (std::exception& e) {
23592       {
23593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23594       };
23595     } catch (...) {
23596       {
23597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23598       };
23599     }
23600   }
23601   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23602   return jresult;
23603 }
23604
23605
23606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23607   void * jresult ;
23608   Dali::Renderer *result = 0 ;
23609
23610   {
23611     try {
23612       result = (Dali::Renderer *)new Dali::Renderer();
23613     } catch (std::out_of_range& e) {
23614       {
23615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23616       };
23617     } catch (std::exception& e) {
23618       {
23619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23620       };
23621     } catch (...) {
23622       {
23623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23624       };
23625     }
23626   }
23627   jresult = (void *)result;
23628   return jresult;
23629 }
23630
23631
23632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23633   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23634
23635   arg1 = (Dali::Renderer *)jarg1;
23636   {
23637     try {
23638       delete arg1;
23639     } catch (std::out_of_range& e) {
23640       {
23641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23642       };
23643     } catch (std::exception& e) {
23644       {
23645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23646       };
23647     } catch (...) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23650       };
23651     }
23652   }
23653 }
23654
23655
23656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23657   void * jresult ;
23658   Dali::Renderer *arg1 = 0 ;
23659   Dali::Renderer *result = 0 ;
23660
23661   arg1 = (Dali::Renderer *)jarg1;
23662   if (!arg1) {
23663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23664     return 0;
23665   }
23666   {
23667     try {
23668       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (...) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23680       };
23681     }
23682   }
23683   jresult = (void *)result;
23684   return jresult;
23685 }
23686
23687
23688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23689   void * jresult ;
23690   Dali::BaseHandle arg1 ;
23691   Dali::BaseHandle *argp1 ;
23692   Dali::Renderer result;
23693
23694   argp1 = (Dali::BaseHandle *)jarg1;
23695   if (!argp1) {
23696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23697     return 0;
23698   }
23699   arg1 = *argp1;
23700   {
23701     try {
23702       result = Dali::Renderer::DownCast(arg1);
23703     } catch (std::out_of_range& e) {
23704       {
23705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23706       };
23707     } catch (std::exception& e) {
23708       {
23709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23710       };
23711     } catch (...) {
23712       {
23713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23714       };
23715     }
23716   }
23717   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23718   return jresult;
23719 }
23720
23721
23722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23723   void * jresult ;
23724   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23725   Dali::Renderer *arg2 = 0 ;
23726   Dali::Renderer *result = 0 ;
23727
23728   arg1 = (Dali::Renderer *)jarg1;
23729   arg2 = (Dali::Renderer *)jarg2;
23730   if (!arg2) {
23731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23732     return 0;
23733   }
23734   {
23735     try {
23736       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23737     } catch (std::out_of_range& e) {
23738       {
23739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23740       };
23741     } catch (std::exception& e) {
23742       {
23743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23744       };
23745     } catch (...) {
23746       {
23747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23748       };
23749     }
23750   }
23751   jresult = (void *)result;
23752   return jresult;
23753 }
23754
23755
23756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23757   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23758   Dali::Geometry *arg2 = 0 ;
23759
23760   arg1 = (Dali::Renderer *)jarg1;
23761   arg2 = (Dali::Geometry *)jarg2;
23762   if (!arg2) {
23763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23764     return ;
23765   }
23766   {
23767     try {
23768       (arg1)->SetGeometry(*arg2);
23769     } catch (std::out_of_range& e) {
23770       {
23771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23772       };
23773     } catch (std::exception& e) {
23774       {
23775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23776       };
23777     } catch (...) {
23778       {
23779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23780       };
23781     }
23782   }
23783 }
23784
23785
23786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23787   void * jresult ;
23788   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23789   Dali::Geometry result;
23790
23791   arg1 = (Dali::Renderer *)jarg1;
23792   {
23793     try {
23794       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23795     } catch (std::out_of_range& e) {
23796       {
23797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23798       };
23799     } catch (std::exception& e) {
23800       {
23801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23802       };
23803     } catch (...) {
23804       {
23805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23806       };
23807     }
23808   }
23809   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23810   return jresult;
23811 }
23812
23813
23814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23815   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23816   int arg2 ;
23817   int arg3 ;
23818
23819   arg1 = (Dali::Renderer *)jarg1;
23820   arg2 = (int)jarg2;
23821   arg3 = (int)jarg3;
23822   {
23823     try {
23824       (arg1)->SetIndexRange(arg2,arg3);
23825     } catch (std::out_of_range& e) {
23826       {
23827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23828       };
23829     } catch (std::exception& e) {
23830       {
23831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23832       };
23833     } catch (...) {
23834       {
23835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23836       };
23837     }
23838   }
23839 }
23840
23841
23842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23843   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23844   Dali::TextureSet *arg2 = 0 ;
23845
23846   arg1 = (Dali::Renderer *)jarg1;
23847   arg2 = (Dali::TextureSet *)jarg2;
23848   if (!arg2) {
23849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23850     return ;
23851   }
23852   {
23853     try {
23854       (arg1)->SetTextures(*arg2);
23855     } catch (std::out_of_range& e) {
23856       {
23857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23858       };
23859     } catch (std::exception& e) {
23860       {
23861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23862       };
23863     } catch (...) {
23864       {
23865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23866       };
23867     }
23868   }
23869 }
23870
23871
23872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23873   void * jresult ;
23874   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23875   Dali::TextureSet result;
23876
23877   arg1 = (Dali::Renderer *)jarg1;
23878   {
23879     try {
23880       result = ((Dali::Renderer const *)arg1)->GetTextures();
23881     } catch (std::out_of_range& e) {
23882       {
23883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23884       };
23885     } catch (std::exception& e) {
23886       {
23887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23888       };
23889     } catch (...) {
23890       {
23891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23892       };
23893     }
23894   }
23895   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23896   return jresult;
23897 }
23898
23899
23900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23901   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23902   Dali::Shader *arg2 = 0 ;
23903
23904   arg1 = (Dali::Renderer *)jarg1;
23905   arg2 = (Dali::Shader *)jarg2;
23906   if (!arg2) {
23907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23908     return ;
23909   }
23910   {
23911     try {
23912       (arg1)->SetShader(*arg2);
23913     } catch (std::out_of_range& e) {
23914       {
23915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23916       };
23917     } catch (std::exception& e) {
23918       {
23919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23920       };
23921     } catch (...) {
23922       {
23923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23924       };
23925     }
23926   }
23927 }
23928
23929
23930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23931   void * jresult ;
23932   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23933   Dali::Shader result;
23934
23935   arg1 = (Dali::Renderer *)jarg1;
23936   {
23937     try {
23938       result = ((Dali::Renderer const *)arg1)->GetShader();
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23950       };
23951     }
23952   }
23953   jresult = new Dali::Shader((const Dali::Shader &)result);
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23959   void * jresult ;
23960   Dali::FrameBuffer::Attachment *result = 0 ;
23961
23962   {
23963     try {
23964       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23965     } catch (std::out_of_range& e) {
23966       {
23967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23968       };
23969     } catch (std::exception& e) {
23970       {
23971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23972       };
23973     } catch (...) {
23974       {
23975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23976       };
23977     }
23978   }
23979   jresult = (void *)result;
23980   return jresult;
23981 }
23982
23983
23984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
23985   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
23986
23987   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
23988   {
23989     try {
23990       delete arg1;
23991     } catch (std::out_of_range& e) {
23992       {
23993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23994       };
23995     } catch (std::exception& e) {
23996       {
23997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23998       };
23999     } catch (...) {
24000       {
24001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24002       };
24003     }
24004   }
24005 }
24006
24007
24008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24009   void * jresult ;
24010   unsigned int arg1 ;
24011   unsigned int arg2 ;
24012   unsigned int arg3 ;
24013   Dali::FrameBuffer result;
24014
24015   arg1 = (unsigned int)jarg1;
24016   arg2 = (unsigned int)jarg2;
24017   arg3 = (unsigned int)jarg3;
24018   {
24019     try {
24020       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24021     } catch (std::out_of_range& e) {
24022       {
24023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (std::exception& e) {
24026       {
24027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24041   void * jresult ;
24042   Dali::FrameBuffer *result = 0 ;
24043
24044   {
24045     try {
24046       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24047     } catch (std::out_of_range& e) {
24048       {
24049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24050       };
24051     } catch (std::exception& e) {
24052       {
24053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24058       };
24059     }
24060   }
24061   jresult = (void *)result;
24062   return jresult;
24063 }
24064
24065
24066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24067   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24068
24069   arg1 = (Dali::FrameBuffer *)jarg1;
24070   {
24071     try {
24072       delete arg1;
24073     } catch (std::out_of_range& e) {
24074       {
24075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24076       };
24077     } catch (std::exception& e) {
24078       {
24079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24080       };
24081     } catch (...) {
24082       {
24083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24084       };
24085     }
24086   }
24087 }
24088
24089
24090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24091   void * jresult ;
24092   Dali::FrameBuffer *arg1 = 0 ;
24093   Dali::FrameBuffer *result = 0 ;
24094
24095   arg1 = (Dali::FrameBuffer *)jarg1;
24096   if (!arg1) {
24097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24098     return 0;
24099   }
24100   {
24101     try {
24102       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24103     } catch (std::out_of_range& e) {
24104       {
24105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (std::exception& e) {
24108       {
24109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24110       };
24111     } catch (...) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24114       };
24115     }
24116   }
24117   jresult = (void *)result;
24118   return jresult;
24119 }
24120
24121
24122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24123   void * jresult ;
24124   Dali::BaseHandle arg1 ;
24125   Dali::BaseHandle *argp1 ;
24126   Dali::FrameBuffer result;
24127
24128   argp1 = (Dali::BaseHandle *)jarg1;
24129   if (!argp1) {
24130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24131     return 0;
24132   }
24133   arg1 = *argp1;
24134   {
24135     try {
24136       result = Dali::FrameBuffer::DownCast(arg1);
24137     } catch (std::out_of_range& e) {
24138       {
24139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24140       };
24141     } catch (std::exception& e) {
24142       {
24143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24144       };
24145     } catch (...) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24148       };
24149     }
24150   }
24151   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24152   return jresult;
24153 }
24154
24155
24156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24157   void * jresult ;
24158   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24159   Dali::FrameBuffer *arg2 = 0 ;
24160   Dali::FrameBuffer *result = 0 ;
24161
24162   arg1 = (Dali::FrameBuffer *)jarg1;
24163   arg2 = (Dali::FrameBuffer *)jarg2;
24164   if (!arg2) {
24165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24166     return 0;
24167   }
24168   {
24169     try {
24170       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24171     } catch (std::out_of_range& e) {
24172       {
24173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24174       };
24175     } catch (std::exception& e) {
24176       {
24177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24178       };
24179     } catch (...) {
24180       {
24181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24182       };
24183     }
24184   }
24185   jresult = (void *)result;
24186   return jresult;
24187 }
24188
24189
24190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24191   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24192   Dali::Texture *arg2 = 0 ;
24193
24194   arg1 = (Dali::FrameBuffer *)jarg1;
24195   arg2 = (Dali::Texture *)jarg2;
24196   if (!arg2) {
24197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24198     return ;
24199   }
24200   {
24201     try {
24202       (arg1)->AttachColorTexture(*arg2);
24203     } catch (std::out_of_range& e) {
24204       {
24205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24206       };
24207     } catch (std::exception& e) {
24208       {
24209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24210       };
24211     } catch (...) {
24212       {
24213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24214       };
24215     }
24216   }
24217 }
24218
24219
24220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24221   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24222   Dali::Texture *arg2 = 0 ;
24223   unsigned int arg3 ;
24224   unsigned int arg4 ;
24225
24226   arg1 = (Dali::FrameBuffer *)jarg1;
24227   arg2 = (Dali::Texture *)jarg2;
24228   if (!arg2) {
24229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24230     return ;
24231   }
24232   arg3 = (unsigned int)jarg3;
24233   arg4 = (unsigned int)jarg4;
24234   {
24235     try {
24236       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24237     } catch (std::out_of_range& e) {
24238       {
24239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24240       };
24241     } catch (std::exception& e) {
24242       {
24243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24244       };
24245     } catch (...) {
24246       {
24247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24248       };
24249     }
24250   }
24251 }
24252
24253
24254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24255   void * jresult ;
24256   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24257   Dali::Texture result;
24258
24259   arg1 = (Dali::FrameBuffer *)jarg1;
24260   {
24261     try {
24262       result = (arg1)->GetColorTexture();
24263     } catch (std::out_of_range& e) {
24264       {
24265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24266       };
24267     } catch (std::exception& e) {
24268       {
24269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24270       };
24271     } catch (...) {
24272       {
24273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24274       };
24275     }
24276   }
24277   jresult = new Dali::Texture((const Dali::Texture &)result);
24278   return jresult;
24279 }
24280
24281
24282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24283   void * jresult ;
24284   Dali::RenderTaskList *result = 0 ;
24285
24286   {
24287     try {
24288       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24289     } catch (std::out_of_range& e) {
24290       {
24291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24292       };
24293     } catch (std::exception& e) {
24294       {
24295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24296       };
24297     } catch (...) {
24298       {
24299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24300       };
24301     }
24302   }
24303   jresult = (void *)result;
24304   return jresult;
24305 }
24306
24307
24308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24309   void * jresult ;
24310   Dali::BaseHandle arg1 ;
24311   Dali::BaseHandle *argp1 ;
24312   Dali::RenderTaskList result;
24313
24314   argp1 = (Dali::BaseHandle *)jarg1;
24315   if (!argp1) {
24316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24317     return 0;
24318   }
24319   arg1 = *argp1;
24320   {
24321     try {
24322       result = Dali::RenderTaskList::DownCast(arg1);
24323     } catch (std::out_of_range& e) {
24324       {
24325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24326       };
24327     } catch (std::exception& e) {
24328       {
24329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24330       };
24331     } catch (...) {
24332       {
24333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24334       };
24335     }
24336   }
24337   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24338   return jresult;
24339 }
24340
24341
24342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24343   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24344
24345   arg1 = (Dali::RenderTaskList *)jarg1;
24346   {
24347     try {
24348       delete arg1;
24349     } catch (std::out_of_range& e) {
24350       {
24351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24352       };
24353     } catch (std::exception& e) {
24354       {
24355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24356       };
24357     } catch (...) {
24358       {
24359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24360       };
24361     }
24362   }
24363 }
24364
24365
24366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24367   void * jresult ;
24368   Dali::RenderTaskList *arg1 = 0 ;
24369   Dali::RenderTaskList *result = 0 ;
24370
24371   arg1 = (Dali::RenderTaskList *)jarg1;
24372   if (!arg1) {
24373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24374     return 0;
24375   }
24376   {
24377     try {
24378       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24379     } catch (std::out_of_range& e) {
24380       {
24381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24382       };
24383     } catch (std::exception& e) {
24384       {
24385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24386       };
24387     } catch (...) {
24388       {
24389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24390       };
24391     }
24392   }
24393   jresult = (void *)result;
24394   return jresult;
24395 }
24396
24397
24398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24399   void * jresult ;
24400   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24401   Dali::RenderTaskList *arg2 = 0 ;
24402   Dali::RenderTaskList *result = 0 ;
24403
24404   arg1 = (Dali::RenderTaskList *)jarg1;
24405   arg2 = (Dali::RenderTaskList *)jarg2;
24406   if (!arg2) {
24407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24408     return 0;
24409   }
24410   {
24411     try {
24412       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24413     } catch (std::out_of_range& e) {
24414       {
24415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24416       };
24417     } catch (std::exception& e) {
24418       {
24419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24420       };
24421     } catch (...) {
24422       {
24423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24424       };
24425     }
24426   }
24427   jresult = (void *)result;
24428   return jresult;
24429 }
24430
24431
24432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24433   void * jresult ;
24434   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24435   Dali::RenderTask result;
24436
24437   arg1 = (Dali::RenderTaskList *)jarg1;
24438   {
24439     try {
24440       result = (arg1)->CreateTask();
24441     } catch (std::out_of_range& e) {
24442       {
24443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24444       };
24445     } catch (std::exception& e) {
24446       {
24447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24448       };
24449     } catch (...) {
24450       {
24451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24452       };
24453     }
24454   }
24455   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24456   return jresult;
24457 }
24458
24459
24460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24461   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24462   Dali::RenderTask arg2 ;
24463   Dali::RenderTask *argp2 ;
24464
24465   arg1 = (Dali::RenderTaskList *)jarg1;
24466   argp2 = (Dali::RenderTask *)jarg2;
24467   if (!argp2) {
24468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24469     return ;
24470   }
24471   arg2 = *argp2;
24472   {
24473     try {
24474       (arg1)->RemoveTask(arg2);
24475     } catch (std::out_of_range& e) {
24476       {
24477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24478       };
24479     } catch (std::exception& e) {
24480       {
24481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24482       };
24483     } catch (...) {
24484       {
24485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24486       };
24487     }
24488   }
24489 }
24490
24491
24492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24493   unsigned int jresult ;
24494   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24495   unsigned int result;
24496
24497   arg1 = (Dali::RenderTaskList *)jarg1;
24498   {
24499     try {
24500       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24501     } catch (std::out_of_range& e) {
24502       {
24503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24504       };
24505     } catch (std::exception& e) {
24506       {
24507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24508       };
24509     } catch (...) {
24510       {
24511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24512       };
24513     }
24514   }
24515   jresult = result;
24516   return jresult;
24517 }
24518
24519
24520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24521   void * jresult ;
24522   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24523   unsigned int arg2 ;
24524   Dali::RenderTask result;
24525
24526   arg1 = (Dali::RenderTaskList *)jarg1;
24527   arg2 = (unsigned int)jarg2;
24528   {
24529     try {
24530       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24531     } catch (std::out_of_range& e) {
24532       {
24533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (std::exception& e) {
24536       {
24537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24538       };
24539     } catch (...) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24542       };
24543     }
24544   }
24545   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24551   int jresult ;
24552   int result;
24553
24554   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24555   jresult = (int)result;
24556   return jresult;
24557 }
24558
24559
24560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24561   int jresult ;
24562   int result;
24563
24564   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24565   jresult = (int)result;
24566   return jresult;
24567 }
24568
24569
24570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24571   int jresult ;
24572   int result;
24573
24574   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24575   jresult = (int)result;
24576   return jresult;
24577 }
24578
24579
24580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24581   int jresult ;
24582   int result;
24583
24584   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24585   jresult = (int)result;
24586   return jresult;
24587 }
24588
24589
24590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24591   void * jresult ;
24592   Dali::RenderTask::Property *result = 0 ;
24593
24594   {
24595     try {
24596       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24597     } catch (std::out_of_range& e) {
24598       {
24599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24600       };
24601     } catch (std::exception& e) {
24602       {
24603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24604       };
24605     } catch (...) {
24606       {
24607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24608       };
24609     }
24610   }
24611   jresult = (void *)result;
24612   return jresult;
24613 }
24614
24615
24616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24617   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24618
24619   arg1 = (Dali::RenderTask::Property *)jarg1;
24620   {
24621     try {
24622       delete arg1;
24623     } catch (std::out_of_range& e) {
24624       {
24625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24626       };
24627     } catch (std::exception& e) {
24628       {
24629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24630       };
24631     } catch (...) {
24632       {
24633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24634       };
24635     }
24636   }
24637 }
24638
24639
24640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24641   void * jresult ;
24642   bool (*result)(Dali::Vector2 &) = 0 ;
24643
24644   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24645   jresult = (void *)result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24651   void * jresult ;
24652   bool (*result)(Dali::Vector2 &) = 0 ;
24653
24654   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24655   jresult = (void *)result;
24656   return jresult;
24657 }
24658
24659
24660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24661   unsigned int jresult ;
24662   bool result;
24663
24664   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24665   jresult = result;
24666   return jresult;
24667 }
24668
24669
24670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24671   unsigned int jresult ;
24672   bool result;
24673
24674   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24675   jresult = result;
24676   return jresult;
24677 }
24678
24679
24680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24681   void * jresult ;
24682   Dali::Vector4 *result = 0 ;
24683
24684   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24685   jresult = (void *)result;
24686   return jresult;
24687 }
24688
24689
24690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24691   unsigned int jresult ;
24692   bool result;
24693
24694   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24695   jresult = result;
24696   return jresult;
24697 }
24698
24699
24700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24701   unsigned int jresult ;
24702   bool result;
24703
24704   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24705   jresult = result;
24706   return jresult;
24707 }
24708
24709
24710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24711   unsigned int jresult ;
24712   unsigned int result;
24713
24714   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24715   jresult = result;
24716   return jresult;
24717 }
24718
24719
24720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24721   void * jresult ;
24722   Dali::RenderTask *result = 0 ;
24723
24724   {
24725     try {
24726       result = (Dali::RenderTask *)new Dali::RenderTask();
24727     } catch (std::out_of_range& e) {
24728       {
24729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24730       };
24731     } catch (std::exception& e) {
24732       {
24733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24734       };
24735     } catch (...) {
24736       {
24737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24738       };
24739     }
24740   }
24741   jresult = (void *)result;
24742   return jresult;
24743 }
24744
24745
24746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24747   void * jresult ;
24748   Dali::BaseHandle arg1 ;
24749   Dali::BaseHandle *argp1 ;
24750   Dali::RenderTask result;
24751
24752   argp1 = (Dali::BaseHandle *)jarg1;
24753   if (!argp1) {
24754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24755     return 0;
24756   }
24757   arg1 = *argp1;
24758   {
24759     try {
24760       result = Dali::RenderTask::DownCast(arg1);
24761     } catch (std::out_of_range& e) {
24762       {
24763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24764       };
24765     } catch (std::exception& e) {
24766       {
24767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24768       };
24769     } catch (...) {
24770       {
24771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24772       };
24773     }
24774   }
24775   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24776   return jresult;
24777 }
24778
24779
24780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24782
24783   arg1 = (Dali::RenderTask *)jarg1;
24784   {
24785     try {
24786       delete arg1;
24787     } catch (std::out_of_range& e) {
24788       {
24789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24790       };
24791     } catch (std::exception& e) {
24792       {
24793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24794       };
24795     } catch (...) {
24796       {
24797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24798       };
24799     }
24800   }
24801 }
24802
24803
24804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24805   void * jresult ;
24806   Dali::RenderTask *arg1 = 0 ;
24807   Dali::RenderTask *result = 0 ;
24808
24809   arg1 = (Dali::RenderTask *)jarg1;
24810   if (!arg1) {
24811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24812     return 0;
24813   }
24814   {
24815     try {
24816       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24817     } catch (std::out_of_range& e) {
24818       {
24819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24820       };
24821     } catch (std::exception& e) {
24822       {
24823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24824       };
24825     } catch (...) {
24826       {
24827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24828       };
24829     }
24830   }
24831   jresult = (void *)result;
24832   return jresult;
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24837   void * jresult ;
24838   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24839   Dali::RenderTask *arg2 = 0 ;
24840   Dali::RenderTask *result = 0 ;
24841
24842   arg1 = (Dali::RenderTask *)jarg1;
24843   arg2 = (Dali::RenderTask *)jarg2;
24844   if (!arg2) {
24845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24846     return 0;
24847   }
24848   {
24849     try {
24850       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24851     } catch (std::out_of_range& e) {
24852       {
24853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24854       };
24855     } catch (std::exception& e) {
24856       {
24857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24858       };
24859     } catch (...) {
24860       {
24861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24862       };
24863     }
24864   }
24865   jresult = (void *)result;
24866   return jresult;
24867 }
24868
24869
24870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24872   Dali::Actor arg2 ;
24873   Dali::Actor *argp2 ;
24874
24875   arg1 = (Dali::RenderTask *)jarg1;
24876   argp2 = (Dali::Actor *)jarg2;
24877   if (!argp2) {
24878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24879     return ;
24880   }
24881   arg2 = *argp2;
24882   {
24883     try {
24884       (arg1)->SetSourceActor(arg2);
24885     } catch (std::out_of_range& e) {
24886       {
24887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24888       };
24889     } catch (std::exception& e) {
24890       {
24891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24892       };
24893     } catch (...) {
24894       {
24895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24896       };
24897     }
24898   }
24899 }
24900
24901
24902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24903   void * jresult ;
24904   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24905   Dali::Actor result;
24906
24907   arg1 = (Dali::RenderTask *)jarg1;
24908   {
24909     try {
24910       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24911     } catch (std::out_of_range& e) {
24912       {
24913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24914       };
24915     } catch (std::exception& e) {
24916       {
24917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24918       };
24919     } catch (...) {
24920       {
24921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24922       };
24923     }
24924   }
24925   jresult = new Dali::Actor((const Dali::Actor &)result);
24926   return jresult;
24927 }
24928
24929
24930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24931   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24932   bool arg2 ;
24933
24934   arg1 = (Dali::RenderTask *)jarg1;
24935   arg2 = jarg2 ? true : false;
24936   {
24937     try {
24938       (arg1)->SetExclusive(arg2);
24939     } catch (std::out_of_range& e) {
24940       {
24941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24942       };
24943     } catch (std::exception& e) {
24944       {
24945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24946       };
24947     } catch (...) {
24948       {
24949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24950       };
24951     }
24952   }
24953 }
24954
24955
24956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24957   unsigned int jresult ;
24958   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24959   bool result;
24960
24961   arg1 = (Dali::RenderTask *)jarg1;
24962   {
24963     try {
24964       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24965     } catch (std::out_of_range& e) {
24966       {
24967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24968       };
24969     } catch (std::exception& e) {
24970       {
24971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24972       };
24973     } catch (...) {
24974       {
24975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24976       };
24977     }
24978   }
24979   jresult = result;
24980   return jresult;
24981 }
24982
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
24985   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24986   bool arg2 ;
24987
24988   arg1 = (Dali::RenderTask *)jarg1;
24989   arg2 = jarg2 ? true : false;
24990   {
24991     try {
24992       (arg1)->SetInputEnabled(arg2);
24993     } catch (std::out_of_range& e) {
24994       {
24995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24996       };
24997     } catch (std::exception& e) {
24998       {
24999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25000       };
25001     } catch (...) {
25002       {
25003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25004       };
25005     }
25006   }
25007 }
25008
25009
25010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25011   unsigned int jresult ;
25012   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25013   bool result;
25014
25015   arg1 = (Dali::RenderTask *)jarg1;
25016   {
25017     try {
25018       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25019     } catch (std::out_of_range& e) {
25020       {
25021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25022       };
25023     } catch (std::exception& e) {
25024       {
25025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25026       };
25027     } catch (...) {
25028       {
25029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25030       };
25031     }
25032   }
25033   jresult = result;
25034   return jresult;
25035 }
25036
25037
25038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25039   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25040   Dali::CameraActor arg2 ;
25041   Dali::CameraActor *argp2 ;
25042
25043   arg1 = (Dali::RenderTask *)jarg1;
25044   argp2 = (Dali::CameraActor *)jarg2;
25045   if (!argp2) {
25046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25047     return ;
25048   }
25049   arg2 = *argp2;
25050   {
25051     try {
25052       (arg1)->SetCameraActor(arg2);
25053     } catch (std::out_of_range& e) {
25054       {
25055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25056       };
25057     } catch (std::exception& e) {
25058       {
25059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25060       };
25061     } catch (...) {
25062       {
25063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25064       };
25065     }
25066   }
25067 }
25068
25069
25070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25071   void * jresult ;
25072   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25073   Dali::CameraActor result;
25074
25075   arg1 = (Dali::RenderTask *)jarg1;
25076   {
25077     try {
25078       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25079     } catch (std::out_of_range& e) {
25080       {
25081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25082       };
25083     } catch (std::exception& e) {
25084       {
25085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25086       };
25087     } catch (...) {
25088       {
25089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25090       };
25091     }
25092   }
25093   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25094   return jresult;
25095 }
25096
25097
25098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25099   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25100   Dali::FrameBufferImage arg2 ;
25101   Dali::FrameBufferImage *argp2 ;
25102
25103   arg1 = (Dali::RenderTask *)jarg1;
25104   argp2 = (Dali::FrameBufferImage *)jarg2;
25105   if (!argp2) {
25106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25107     return ;
25108   }
25109   arg2 = *argp2;
25110   {
25111     try {
25112       (arg1)->SetTargetFrameBuffer(arg2);
25113     } catch (std::out_of_range& e) {
25114       {
25115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25116       };
25117     } catch (std::exception& e) {
25118       {
25119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (...) {
25122       {
25123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25124       };
25125     }
25126   }
25127 }
25128
25129
25130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25131   void * jresult ;
25132   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25133   Dali::FrameBufferImage result;
25134
25135   arg1 = (Dali::RenderTask *)jarg1;
25136   {
25137     try {
25138       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25139     } catch (std::out_of_range& e) {
25140       {
25141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25142       };
25143     } catch (std::exception& e) {
25144       {
25145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25146       };
25147     } catch (...) {
25148       {
25149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25150       };
25151     }
25152   }
25153   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25154   return jresult;
25155 }
25156
25157
25158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25159   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25160   Dali::FrameBuffer arg2 ;
25161   Dali::FrameBuffer *argp2 ;
25162
25163   arg1 = (Dali::RenderTask *)jarg1;
25164   argp2 = (Dali::FrameBuffer *)jarg2;
25165   if (!argp2) {
25166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25167     return ;
25168   }
25169   arg2 = *argp2;
25170   {
25171     try {
25172       (arg1)->SetFrameBuffer(arg2);
25173     } catch (std::out_of_range& e) {
25174       {
25175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25176       };
25177     } catch (std::exception& e) {
25178       {
25179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25180       };
25181     } catch (...) {
25182       {
25183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25184       };
25185     }
25186   }
25187 }
25188
25189
25190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25191   void * jresult ;
25192   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25193   Dali::FrameBuffer result;
25194
25195   arg1 = (Dali::RenderTask *)jarg1;
25196   {
25197     try {
25198       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25199     } catch (std::out_of_range& e) {
25200       {
25201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (std::exception& e) {
25204       {
25205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25214   return jresult;
25215 }
25216
25217
25218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25219   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25220   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25221
25222   arg1 = (Dali::RenderTask *)jarg1;
25223   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25224   {
25225     try {
25226       (arg1)->SetScreenToFrameBufferFunction(arg2);
25227     } catch (std::out_of_range& e) {
25228       {
25229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25230       };
25231     } catch (std::exception& e) {
25232       {
25233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25234       };
25235     } catch (...) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25238       };
25239     }
25240   }
25241 }
25242
25243
25244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25245   void * jresult ;
25246   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25247   Dali::RenderTask::ScreenToFrameBufferFunction result;
25248
25249   arg1 = (Dali::RenderTask *)jarg1;
25250   {
25251     try {
25252       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25253     } catch (std::out_of_range& e) {
25254       {
25255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25256       };
25257     } catch (std::exception& e) {
25258       {
25259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25260       };
25261     } catch (...) {
25262       {
25263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25264       };
25265     }
25266   }
25267   jresult = (void *)result;
25268   return jresult;
25269 }
25270
25271
25272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25273   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25274   Dali::Actor arg2 ;
25275   Dali::Actor *argp2 ;
25276
25277   arg1 = (Dali::RenderTask *)jarg1;
25278   argp2 = (Dali::Actor *)jarg2;
25279   if (!argp2) {
25280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25281     return ;
25282   }
25283   arg2 = *argp2;
25284   {
25285     try {
25286       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25287     } catch (std::out_of_range& e) {
25288       {
25289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25290       };
25291     } catch (std::exception& e) {
25292       {
25293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25294       };
25295     } catch (...) {
25296       {
25297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25298       };
25299     }
25300   }
25301 }
25302
25303
25304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25305   void * jresult ;
25306   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25307   Dali::Actor result;
25308
25309   arg1 = (Dali::RenderTask *)jarg1;
25310   {
25311     try {
25312       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25313     } catch (std::out_of_range& e) {
25314       {
25315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25316       };
25317     } catch (std::exception& e) {
25318       {
25319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25320       };
25321     } catch (...) {
25322       {
25323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25324       };
25325     }
25326   }
25327   jresult = new Dali::Actor((const Dali::Actor &)result);
25328   return jresult;
25329 }
25330
25331
25332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25333   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25334   Dali::Vector2 arg2 ;
25335   Dali::Vector2 *argp2 ;
25336
25337   arg1 = (Dali::RenderTask *)jarg1;
25338   argp2 = (Dali::Vector2 *)jarg2;
25339   if (!argp2) {
25340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25341     return ;
25342   }
25343   arg2 = *argp2;
25344   {
25345     try {
25346       (arg1)->SetViewportPosition(arg2);
25347     } catch (std::out_of_range& e) {
25348       {
25349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25350       };
25351     } catch (std::exception& e) {
25352       {
25353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (...) {
25356       {
25357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25358       };
25359     }
25360   }
25361 }
25362
25363
25364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25365   void * jresult ;
25366   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25367   Dali::Vector2 result;
25368
25369   arg1 = (Dali::RenderTask *)jarg1;
25370   {
25371     try {
25372       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25373     } catch (std::out_of_range& e) {
25374       {
25375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25376       };
25377     } catch (std::exception& e) {
25378       {
25379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (...) {
25382       {
25383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25384       };
25385     }
25386   }
25387   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25388   return jresult;
25389 }
25390
25391
25392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25393   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25394   Dali::Vector2 arg2 ;
25395   Dali::Vector2 *argp2 ;
25396
25397   arg1 = (Dali::RenderTask *)jarg1;
25398   argp2 = (Dali::Vector2 *)jarg2;
25399   if (!argp2) {
25400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25401     return ;
25402   }
25403   arg2 = *argp2;
25404   {
25405     try {
25406       (arg1)->SetViewportSize(arg2);
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25414       };
25415     } catch (...) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25418       };
25419     }
25420   }
25421 }
25422
25423
25424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25425   void * jresult ;
25426   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25427   Dali::Vector2 result;
25428
25429   arg1 = (Dali::RenderTask *)jarg1;
25430   {
25431     try {
25432       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25433     } catch (std::out_of_range& e) {
25434       {
25435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25436       };
25437     } catch (std::exception& e) {
25438       {
25439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25440       };
25441     } catch (...) {
25442       {
25443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25444       };
25445     }
25446   }
25447   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25448   return jresult;
25449 }
25450
25451
25452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25453   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25454   Dali::Viewport arg2 ;
25455   Dali::Viewport *argp2 ;
25456
25457   arg1 = (Dali::RenderTask *)jarg1;
25458   argp2 = (Dali::Viewport *)jarg2;
25459   if (!argp2) {
25460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25461     return ;
25462   }
25463   arg2 = *argp2;
25464   {
25465     try {
25466       (arg1)->SetViewport(arg2);
25467     } catch (std::out_of_range& e) {
25468       {
25469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25470       };
25471     } catch (std::exception& e) {
25472       {
25473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25474       };
25475     } catch (...) {
25476       {
25477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25478       };
25479     }
25480   }
25481 }
25482
25483
25484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25485   void * jresult ;
25486   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25487   Dali::Viewport result;
25488
25489   arg1 = (Dali::RenderTask *)jarg1;
25490   {
25491     try {
25492       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25493     } catch (std::out_of_range& e) {
25494       {
25495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25496       };
25497     } catch (std::exception& e) {
25498       {
25499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25500       };
25501     } catch (...) {
25502       {
25503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25504       };
25505     }
25506   }
25507   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25508   return jresult;
25509 }
25510
25511
25512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25513   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25514   Dali::Vector4 *arg2 = 0 ;
25515
25516   arg1 = (Dali::RenderTask *)jarg1;
25517   arg2 = (Dali::Vector4 *)jarg2;
25518   if (!arg2) {
25519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25520     return ;
25521   }
25522   {
25523     try {
25524       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25525     } catch (std::out_of_range& e) {
25526       {
25527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25528       };
25529     } catch (std::exception& e) {
25530       {
25531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25532       };
25533     } catch (...) {
25534       {
25535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25536       };
25537     }
25538   }
25539 }
25540
25541
25542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25543   void * jresult ;
25544   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25545   Dali::Vector4 result;
25546
25547   arg1 = (Dali::RenderTask *)jarg1;
25548   {
25549     try {
25550       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25551     } catch (std::out_of_range& e) {
25552       {
25553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25554       };
25555     } catch (std::exception& e) {
25556       {
25557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25558       };
25559     } catch (...) {
25560       {
25561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25562       };
25563     }
25564   }
25565   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25566   return jresult;
25567 }
25568
25569
25570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25571   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25572   bool arg2 ;
25573
25574   arg1 = (Dali::RenderTask *)jarg1;
25575   arg2 = jarg2 ? true : false;
25576   {
25577     try {
25578       (arg1)->SetClearEnabled(arg2);
25579     } catch (std::out_of_range& e) {
25580       {
25581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25582       };
25583     } catch (std::exception& e) {
25584       {
25585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25586       };
25587     } catch (...) {
25588       {
25589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25590       };
25591     }
25592   }
25593 }
25594
25595
25596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25597   unsigned int jresult ;
25598   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25599   bool result;
25600
25601   arg1 = (Dali::RenderTask *)jarg1;
25602   {
25603     try {
25604       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25605     } catch (std::out_of_range& e) {
25606       {
25607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (std::exception& e) {
25610       {
25611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25612       };
25613     } catch (...) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25616       };
25617     }
25618   }
25619   jresult = result;
25620   return jresult;
25621 }
25622
25623
25624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25625   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25626   bool arg2 ;
25627
25628   arg1 = (Dali::RenderTask *)jarg1;
25629   arg2 = jarg2 ? true : false;
25630   {
25631     try {
25632       (arg1)->SetCullMode(arg2);
25633     } catch (std::out_of_range& e) {
25634       {
25635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25636       };
25637     } catch (std::exception& e) {
25638       {
25639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25640       };
25641     } catch (...) {
25642       {
25643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25644       };
25645     }
25646   }
25647 }
25648
25649
25650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25651   unsigned int jresult ;
25652   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25653   bool result;
25654
25655   arg1 = (Dali::RenderTask *)jarg1;
25656   {
25657     try {
25658       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25659     } catch (std::out_of_range& e) {
25660       {
25661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (std::exception& e) {
25664       {
25665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25666       };
25667     } catch (...) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25670       };
25671     }
25672   }
25673   jresult = result;
25674   return jresult;
25675 }
25676
25677
25678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25679   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25680   unsigned int arg2 ;
25681
25682   arg1 = (Dali::RenderTask *)jarg1;
25683   arg2 = (unsigned int)jarg2;
25684   {
25685     try {
25686       (arg1)->SetRefreshRate(arg2);
25687     } catch (std::out_of_range& e) {
25688       {
25689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25690       };
25691     } catch (std::exception& e) {
25692       {
25693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25698       };
25699     }
25700   }
25701 }
25702
25703
25704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25705   unsigned int jresult ;
25706   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25707   unsigned int result;
25708
25709   arg1 = (Dali::RenderTask *)jarg1;
25710   {
25711     try {
25712       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25713     } catch (std::out_of_range& e) {
25714       {
25715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25716       };
25717     } catch (std::exception& e) {
25718       {
25719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (...) {
25722       {
25723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25724       };
25725     }
25726   }
25727   jresult = result;
25728   return jresult;
25729 }
25730
25731
25732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25733   unsigned int jresult ;
25734   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25735   Dali::Vector3 *arg2 = 0 ;
25736   float *arg3 = 0 ;
25737   float *arg4 = 0 ;
25738   bool result;
25739
25740   arg1 = (Dali::RenderTask *)jarg1;
25741   arg2 = (Dali::Vector3 *)jarg2;
25742   if (!arg2) {
25743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25744     return 0;
25745   }
25746   arg3 = (float *)jarg3;
25747   arg4 = (float *)jarg4;
25748   {
25749     try {
25750       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (...) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25762       };
25763     }
25764   }
25765   jresult = result;
25766   return jresult;
25767 }
25768
25769
25770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25771   unsigned int jresult ;
25772   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25773   Dali::Actor arg2 ;
25774   float arg3 ;
25775   float arg4 ;
25776   float *arg5 = 0 ;
25777   float *arg6 = 0 ;
25778   Dali::Actor *argp2 ;
25779   bool result;
25780
25781   arg1 = (Dali::RenderTask *)jarg1;
25782   argp2 = (Dali::Actor *)jarg2;
25783   if (!argp2) {
25784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25785     return 0;
25786   }
25787   arg2 = *argp2;
25788   arg3 = (float)jarg3;
25789   arg4 = (float)jarg4;
25790   arg5 = (float *)jarg5;
25791   arg6 = (float *)jarg6;
25792   {
25793     try {
25794       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25795     } catch (std::out_of_range& e) {
25796       {
25797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25798       };
25799     } catch (std::exception& e) {
25800       {
25801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25802       };
25803     } catch (...) {
25804       {
25805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25806       };
25807     }
25808   }
25809   jresult = result;
25810   return jresult;
25811 }
25812
25813
25814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25815   void * jresult ;
25816   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25817   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25818
25819   arg1 = (Dali::RenderTask *)jarg1;
25820   {
25821     try {
25822       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25823     } catch (std::out_of_range& e) {
25824       {
25825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25826       };
25827     } catch (std::exception& e) {
25828       {
25829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25830       };
25831     } catch (...) {
25832       {
25833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25834       };
25835     }
25836   }
25837   jresult = (void *)result;
25838   return jresult;
25839 }
25840
25841
25842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25843   void * jresult ;
25844   int arg1 ;
25845   Dali::TouchPoint::State arg2 ;
25846   float arg3 ;
25847   float arg4 ;
25848   Dali::TouchPoint *result = 0 ;
25849
25850   arg1 = (int)jarg1;
25851   arg2 = (Dali::TouchPoint::State)jarg2;
25852   arg3 = (float)jarg3;
25853   arg4 = (float)jarg4;
25854   {
25855     try {
25856       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25857     } catch (std::out_of_range& e) {
25858       {
25859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25860       };
25861     } catch (std::exception& e) {
25862       {
25863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25864       };
25865     } catch (...) {
25866       {
25867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25868       };
25869     }
25870   }
25871   jresult = (void *)result;
25872   return jresult;
25873 }
25874
25875
25876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25877   void * jresult ;
25878   int arg1 ;
25879   Dali::TouchPoint::State arg2 ;
25880   float arg3 ;
25881   float arg4 ;
25882   float arg5 ;
25883   float arg6 ;
25884   Dali::TouchPoint *result = 0 ;
25885
25886   arg1 = (int)jarg1;
25887   arg2 = (Dali::TouchPoint::State)jarg2;
25888   arg3 = (float)jarg3;
25889   arg4 = (float)jarg4;
25890   arg5 = (float)jarg5;
25891   arg6 = (float)jarg6;
25892   {
25893     try {
25894       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25895     } catch (std::out_of_range& e) {
25896       {
25897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (std::exception& e) {
25900       {
25901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (...) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25906       };
25907     }
25908   }
25909   jresult = (void *)result;
25910   return jresult;
25911 }
25912
25913
25914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25915   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25916
25917   arg1 = (Dali::TouchPoint *)jarg1;
25918   {
25919     try {
25920       delete arg1;
25921     } catch (std::out_of_range& e) {
25922       {
25923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25924       };
25925     } catch (std::exception& e) {
25926       {
25927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25928       };
25929     } catch (...) {
25930       {
25931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25932       };
25933     }
25934   }
25935 }
25936
25937
25938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25939   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25940   int arg2 ;
25941
25942   arg1 = (Dali::TouchPoint *)jarg1;
25943   arg2 = (int)jarg2;
25944   if (arg1) (arg1)->deviceId = arg2;
25945 }
25946
25947
25948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25949   int jresult ;
25950   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25951   int result;
25952
25953   arg1 = (Dali::TouchPoint *)jarg1;
25954   result = (int) ((arg1)->deviceId);
25955   jresult = result;
25956   return jresult;
25957 }
25958
25959
25960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25961   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25962   Dali::TouchPoint::State arg2 ;
25963
25964   arg1 = (Dali::TouchPoint *)jarg1;
25965   arg2 = (Dali::TouchPoint::State)jarg2;
25966   if (arg1) (arg1)->state = arg2;
25967 }
25968
25969
25970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25971   int jresult ;
25972   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25973   Dali::TouchPoint::State result;
25974
25975   arg1 = (Dali::TouchPoint *)jarg1;
25976   result = (Dali::TouchPoint::State) ((arg1)->state);
25977   jresult = (int)result;
25978   return jresult;
25979 }
25980
25981
25982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
25983   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25984   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25985
25986   arg1 = (Dali::TouchPoint *)jarg1;
25987   arg2 = (Dali::Actor *)jarg2;
25988   if (arg1) (arg1)->hitActor = *arg2;
25989 }
25990
25991
25992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
25993   void * jresult ;
25994   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25995   Dali::Actor *result = 0 ;
25996
25997   arg1 = (Dali::TouchPoint *)jarg1;
25998   result = (Dali::Actor *)& ((arg1)->hitActor);
25999   jresult = (void *)result;
26000   return jresult;
26001 }
26002
26003
26004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26005   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26006   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26007
26008   arg1 = (Dali::TouchPoint *)jarg1;
26009   arg2 = (Dali::Vector2 *)jarg2;
26010   if (arg1) (arg1)->local = *arg2;
26011 }
26012
26013
26014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26015   void * jresult ;
26016   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26017   Dali::Vector2 *result = 0 ;
26018
26019   arg1 = (Dali::TouchPoint *)jarg1;
26020   result = (Dali::Vector2 *)& ((arg1)->local);
26021   jresult = (void *)result;
26022   return jresult;
26023 }
26024
26025
26026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26027   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26028   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26029
26030   arg1 = (Dali::TouchPoint *)jarg1;
26031   arg2 = (Dali::Vector2 *)jarg2;
26032   if (arg1) (arg1)->screen = *arg2;
26033 }
26034
26035
26036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26037   void * jresult ;
26038   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26039   Dali::Vector2 *result = 0 ;
26040
26041   arg1 = (Dali::TouchPoint *)jarg1;
26042   result = (Dali::Vector2 *)& ((arg1)->screen);
26043   jresult = (void *)result;
26044   return jresult;
26045 }
26046
26047
26048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26049   void * jresult ;
26050   Dali::TouchData *result = 0 ;
26051
26052   {
26053     try {
26054       result = (Dali::TouchData *)new Dali::TouchData();
26055     } catch (std::out_of_range& e) {
26056       {
26057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26058       };
26059     } catch (std::exception& e) {
26060       {
26061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26062       };
26063     } catch (...) {
26064       {
26065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26066       };
26067     }
26068   }
26069   jresult = (void *)result;
26070   return jresult;
26071 }
26072
26073
26074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26075   void * jresult ;
26076   Dali::TouchData *arg1 = 0 ;
26077   Dali::TouchData *result = 0 ;
26078
26079   arg1 = (Dali::TouchData *)jarg1;
26080   if (!arg1) {
26081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26082     return 0;
26083   }
26084   {
26085     try {
26086       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26087     } catch (std::out_of_range& e) {
26088       {
26089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26090       };
26091     } catch (std::exception& e) {
26092       {
26093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26094       };
26095     } catch (...) {
26096       {
26097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26098       };
26099     }
26100   }
26101   jresult = (void *)result;
26102   return jresult;
26103 }
26104
26105
26106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26107   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26108
26109   arg1 = (Dali::TouchData *)jarg1;
26110   {
26111     try {
26112       delete arg1;
26113     } catch (std::out_of_range& e) {
26114       {
26115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26116       };
26117     } catch (std::exception& e) {
26118       {
26119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26124       };
26125     }
26126   }
26127 }
26128
26129
26130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26131   void * jresult ;
26132   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26133   Dali::TouchData *arg2 = 0 ;
26134   Dali::TouchData *result = 0 ;
26135
26136   arg1 = (Dali::TouchData *)jarg1;
26137   arg2 = (Dali::TouchData *)jarg2;
26138   if (!arg2) {
26139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26140     return 0;
26141   }
26142   {
26143     try {
26144       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26145     } catch (std::out_of_range& e) {
26146       {
26147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26148       };
26149     } catch (std::exception& e) {
26150       {
26151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26152       };
26153     } catch (...) {
26154       {
26155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26156       };
26157     }
26158   }
26159   jresult = (void *)result;
26160   return jresult;
26161 }
26162
26163
26164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26165   unsigned long jresult ;
26166   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26167   unsigned long result;
26168
26169   arg1 = (Dali::TouchData *)jarg1;
26170   {
26171     try {
26172       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26173     } catch (std::out_of_range& e) {
26174       {
26175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26176       };
26177     } catch (std::exception& e) {
26178       {
26179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26180       };
26181     } catch (...) {
26182       {
26183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26184       };
26185     }
26186   }
26187   jresult = (unsigned long)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26193   unsigned long jresult ;
26194   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26195   std::size_t result;
26196
26197   arg1 = (Dali::TouchData *)jarg1;
26198   {
26199     try {
26200       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26201     } catch (std::out_of_range& e) {
26202       {
26203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26204       };
26205     } catch (std::exception& e) {
26206       {
26207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26208       };
26209     } catch (...) {
26210       {
26211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26212       };
26213     }
26214   }
26215   jresult = (unsigned long)result;
26216   return jresult;
26217 }
26218
26219
26220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26221   int jresult ;
26222   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26223   std::size_t arg2 ;
26224   int32_t result;
26225
26226   arg1 = (Dali::TouchData *)jarg1;
26227   arg2 = (std::size_t)jarg2;
26228   {
26229     try {
26230       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26231     } catch (std::out_of_range& e) {
26232       {
26233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26234       };
26235     } catch (std::exception& e) {
26236       {
26237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26238       };
26239     } catch (...) {
26240       {
26241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26242       };
26243     }
26244   }
26245   jresult = result;
26246   return jresult;
26247 }
26248
26249
26250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26251   int jresult ;
26252   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26253   std::size_t arg2 ;
26254   Dali::PointState::Type result;
26255
26256   arg1 = (Dali::TouchData *)jarg1;
26257   arg2 = (std::size_t)jarg2;
26258   {
26259     try {
26260       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26261     } catch (std::out_of_range& e) {
26262       {
26263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26264       };
26265     } catch (std::exception& e) {
26266       {
26267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26268       };
26269     } catch (...) {
26270       {
26271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26272       };
26273     }
26274   }
26275   jresult = (int)result;
26276   return jresult;
26277 }
26278
26279
26280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26281   void * jresult ;
26282   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26283   std::size_t arg2 ;
26284   Dali::Actor result;
26285
26286   arg1 = (Dali::TouchData *)jarg1;
26287   arg2 = (std::size_t)jarg2;
26288   {
26289     try {
26290       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26291     } catch (std::out_of_range& e) {
26292       {
26293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26294       };
26295     } catch (std::exception& e) {
26296       {
26297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26298       };
26299     } catch (...) {
26300       {
26301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26302       };
26303     }
26304   }
26305   jresult = new Dali::Actor((const Dali::Actor &)result);
26306   return jresult;
26307 }
26308
26309
26310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26311   void * jresult ;
26312   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26313   std::size_t arg2 ;
26314   Dali::Vector2 *result = 0 ;
26315
26316   arg1 = (Dali::TouchData *)jarg1;
26317   arg2 = (std::size_t)jarg2;
26318   {
26319     try {
26320       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26321     } catch (std::out_of_range& e) {
26322       {
26323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26324       };
26325     } catch (std::exception& e) {
26326       {
26327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (...) {
26330       {
26331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26332       };
26333     }
26334   }
26335   jresult = (void *)result;
26336   return jresult;
26337 }
26338
26339
26340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26341   void * jresult ;
26342   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26343   std::size_t arg2 ;
26344   Dali::Vector2 *result = 0 ;
26345
26346   arg1 = (Dali::TouchData *)jarg1;
26347   arg2 = (std::size_t)jarg2;
26348   {
26349     try {
26350       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26351     } catch (std::out_of_range& e) {
26352       {
26353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26354       };
26355     } catch (std::exception& e) {
26356       {
26357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26358       };
26359     } catch (...) {
26360       {
26361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26362       };
26363     }
26364   }
26365   jresult = (void *)result;
26366   return jresult;
26367 }
26368
26369
26370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26371   float jresult ;
26372   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26373   std::size_t arg2 ;
26374   float result;
26375
26376   arg1 = (Dali::TouchData *)jarg1;
26377   arg2 = (std::size_t)jarg2;
26378   {
26379     try {
26380       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26381     } catch (std::out_of_range& e) {
26382       {
26383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26384       };
26385     } catch (std::exception& e) {
26386       {
26387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26388       };
26389     } catch (...) {
26390       {
26391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26392       };
26393     }
26394   }
26395   jresult = result;
26396   return jresult;
26397 }
26398
26399
26400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26401   void * jresult ;
26402   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26403   std::size_t arg2 ;
26404   Dali::Vector2 *result = 0 ;
26405
26406   arg1 = (Dali::TouchData *)jarg1;
26407   arg2 = (std::size_t)jarg2;
26408   {
26409     try {
26410       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26411     } catch (std::out_of_range& e) {
26412       {
26413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26414       };
26415     } catch (std::exception& e) {
26416       {
26417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26418       };
26419     } catch (...) {
26420       {
26421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26422       };
26423     }
26424   }
26425   jresult = (void *)result;
26426   return jresult;
26427 }
26428
26429
26430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26431   float jresult ;
26432   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26433   std::size_t arg2 ;
26434   float result;
26435
26436   arg1 = (Dali::TouchData *)jarg1;
26437   arg2 = (std::size_t)jarg2;
26438   {
26439     try {
26440       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26441     } catch (std::out_of_range& e) {
26442       {
26443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26444       };
26445     } catch (std::exception& e) {
26446       {
26447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26448       };
26449     } catch (...) {
26450       {
26451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26452       };
26453     }
26454   }
26455   jresult = result;
26456   return jresult;
26457 }
26458
26459
26460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26461   void * jresult ;
26462   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26463   std::size_t arg2 ;
26464   Dali::Degree result;
26465
26466   arg1 = (Dali::TouchData *)jarg1;
26467   arg2 = (std::size_t)jarg2;
26468   {
26469     try {
26470       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26471     } catch (std::out_of_range& e) {
26472       {
26473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (std::exception& e) {
26476       {
26477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26482       };
26483     }
26484   }
26485   jresult = new Dali::Degree((const Dali::Degree &)result);
26486   return jresult;
26487 }
26488
26489
26490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26491   void * jresult ;
26492   Dali::GestureDetector *result = 0 ;
26493
26494   {
26495     try {
26496       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26497     } catch (std::out_of_range& e) {
26498       {
26499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26500       };
26501     } catch (std::exception& e) {
26502       {
26503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26504       };
26505     } catch (...) {
26506       {
26507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26508       };
26509     }
26510   }
26511   jresult = (void *)result;
26512   return jresult;
26513 }
26514
26515
26516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26517   void * jresult ;
26518   Dali::BaseHandle arg1 ;
26519   Dali::BaseHandle *argp1 ;
26520   Dali::GestureDetector result;
26521
26522   argp1 = (Dali::BaseHandle *)jarg1;
26523   if (!argp1) {
26524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26525     return 0;
26526   }
26527   arg1 = *argp1;
26528   {
26529     try {
26530       result = Dali::GestureDetector::DownCast(arg1);
26531     } catch (std::out_of_range& e) {
26532       {
26533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26534       };
26535     } catch (std::exception& e) {
26536       {
26537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26538       };
26539     } catch (...) {
26540       {
26541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26542       };
26543     }
26544   }
26545   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26546   return jresult;
26547 }
26548
26549
26550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26551   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26552
26553   arg1 = (Dali::GestureDetector *)jarg1;
26554   {
26555     try {
26556       delete arg1;
26557     } catch (std::out_of_range& e) {
26558       {
26559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26560       };
26561     } catch (std::exception& e) {
26562       {
26563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26564       };
26565     } catch (...) {
26566       {
26567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26568       };
26569     }
26570   }
26571 }
26572
26573
26574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26575   void * jresult ;
26576   Dali::GestureDetector *arg1 = 0 ;
26577   Dali::GestureDetector *result = 0 ;
26578
26579   arg1 = (Dali::GestureDetector *)jarg1;
26580   if (!arg1) {
26581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26582     return 0;
26583   }
26584   {
26585     try {
26586       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26587     } catch (std::out_of_range& e) {
26588       {
26589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26590       };
26591     } catch (std::exception& e) {
26592       {
26593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26594       };
26595     } catch (...) {
26596       {
26597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26598       };
26599     }
26600   }
26601   jresult = (void *)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26607   void * jresult ;
26608   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26609   Dali::GestureDetector *arg2 = 0 ;
26610   Dali::GestureDetector *result = 0 ;
26611
26612   arg1 = (Dali::GestureDetector *)jarg1;
26613   arg2 = (Dali::GestureDetector *)jarg2;
26614   if (!arg2) {
26615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26616     return 0;
26617   }
26618   {
26619     try {
26620       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26621     } catch (std::out_of_range& e) {
26622       {
26623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26624       };
26625     } catch (std::exception& e) {
26626       {
26627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26628       };
26629     } catch (...) {
26630       {
26631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26632       };
26633     }
26634   }
26635   jresult = (void *)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26641   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26642   Dali::Actor arg2 ;
26643   Dali::Actor *argp2 ;
26644
26645   arg1 = (Dali::GestureDetector *)jarg1;
26646   argp2 = (Dali::Actor *)jarg2;
26647   if (!argp2) {
26648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26649     return ;
26650   }
26651   arg2 = *argp2;
26652   {
26653     try {
26654       (arg1)->Attach(arg2);
26655     } catch (std::out_of_range& e) {
26656       {
26657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26658       };
26659     } catch (std::exception& e) {
26660       {
26661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26662       };
26663     } catch (...) {
26664       {
26665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26666       };
26667     }
26668   }
26669 }
26670
26671
26672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26673   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26674   Dali::Actor arg2 ;
26675   Dali::Actor *argp2 ;
26676
26677   arg1 = (Dali::GestureDetector *)jarg1;
26678   argp2 = (Dali::Actor *)jarg2;
26679   if (!argp2) {
26680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26681     return ;
26682   }
26683   arg2 = *argp2;
26684   {
26685     try {
26686       (arg1)->Detach(arg2);
26687     } catch (std::out_of_range& e) {
26688       {
26689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26690       };
26691     } catch (std::exception& e) {
26692       {
26693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26694       };
26695     } catch (...) {
26696       {
26697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26698       };
26699     }
26700   }
26701 }
26702
26703
26704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26705   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26706
26707   arg1 = (Dali::GestureDetector *)jarg1;
26708   {
26709     try {
26710       (arg1)->DetachAll();
26711     } catch (std::out_of_range& e) {
26712       {
26713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26714       };
26715     } catch (std::exception& e) {
26716       {
26717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26718       };
26719     } catch (...) {
26720       {
26721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26722       };
26723     }
26724   }
26725 }
26726
26727
26728 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26729   unsigned long jresult ;
26730   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26731   size_t result;
26732
26733   arg1 = (Dali::GestureDetector *)jarg1;
26734   {
26735     try {
26736       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26737     } catch (std::out_of_range& e) {
26738       {
26739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26740       };
26741     } catch (std::exception& e) {
26742       {
26743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26744       };
26745     } catch (...) {
26746       {
26747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26748       };
26749     }
26750   }
26751   jresult = (unsigned long)result;
26752   return jresult;
26753 }
26754
26755
26756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26757   void * jresult ;
26758   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26759   size_t arg2 ;
26760   Dali::Actor result;
26761
26762   arg1 = (Dali::GestureDetector *)jarg1;
26763   arg2 = (size_t)jarg2;
26764   {
26765     try {
26766       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26767     } catch (std::out_of_range& e) {
26768       {
26769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26770       };
26771     } catch (std::exception& e) {
26772       {
26773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26774       };
26775     } catch (...) {
26776       {
26777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26778       };
26779     }
26780   }
26781   jresult = new Dali::Actor((const Dali::Actor &)result);
26782   return jresult;
26783 }
26784
26785
26786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26787   void * jresult ;
26788   Dali::Gesture *arg1 = 0 ;
26789   Dali::Gesture *result = 0 ;
26790
26791   arg1 = (Dali::Gesture *)jarg1;
26792   if (!arg1) {
26793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26794     return 0;
26795   }
26796   {
26797     try {
26798       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26799     } catch (std::out_of_range& e) {
26800       {
26801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26802       };
26803     } catch (std::exception& e) {
26804       {
26805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26806       };
26807     } catch (...) {
26808       {
26809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26810       };
26811     }
26812   }
26813   jresult = (void *)result;
26814   return jresult;
26815 }
26816
26817
26818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26819   void * jresult ;
26820   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26821   Dali::Gesture *arg2 = 0 ;
26822   Dali::Gesture *result = 0 ;
26823
26824   arg1 = (Dali::Gesture *)jarg1;
26825   arg2 = (Dali::Gesture *)jarg2;
26826   if (!arg2) {
26827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26828     return 0;
26829   }
26830   {
26831     try {
26832       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26833     } catch (std::out_of_range& e) {
26834       {
26835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26836       };
26837     } catch (std::exception& e) {
26838       {
26839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26840       };
26841     } catch (...) {
26842       {
26843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26844       };
26845     }
26846   }
26847   jresult = (void *)result;
26848   return jresult;
26849 }
26850
26851
26852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26853   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26854
26855   arg1 = (Dali::Gesture *)jarg1;
26856   {
26857     try {
26858       delete arg1;
26859     } catch (std::out_of_range& e) {
26860       {
26861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26862       };
26863     } catch (std::exception& e) {
26864       {
26865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26866       };
26867     } catch (...) {
26868       {
26869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26870       };
26871     }
26872   }
26873 }
26874
26875
26876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26877   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26878   Dali::Gesture::Type arg2 ;
26879
26880   arg1 = (Dali::Gesture *)jarg1;
26881   arg2 = (Dali::Gesture::Type)jarg2;
26882   if (arg1) (arg1)->type = arg2;
26883 }
26884
26885
26886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26887   int jresult ;
26888   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26889   Dali::Gesture::Type result;
26890
26891   arg1 = (Dali::Gesture *)jarg1;
26892   result = (Dali::Gesture::Type) ((arg1)->type);
26893   jresult = (int)result;
26894   return jresult;
26895 }
26896
26897
26898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26899   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26900   Dali::Gesture::State arg2 ;
26901
26902   arg1 = (Dali::Gesture *)jarg1;
26903   arg2 = (Dali::Gesture::State)jarg2;
26904   if (arg1) (arg1)->state = arg2;
26905 }
26906
26907
26908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26909   int jresult ;
26910   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26911   Dali::Gesture::State result;
26912
26913   arg1 = (Dali::Gesture *)jarg1;
26914   result = (Dali::Gesture::State) ((arg1)->state);
26915   jresult = (int)result;
26916   return jresult;
26917 }
26918
26919
26920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26921   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26922   unsigned int arg2 ;
26923
26924   arg1 = (Dali::Gesture *)jarg1;
26925   arg2 = (unsigned int)jarg2;
26926   if (arg1) (arg1)->time = arg2;
26927 }
26928
26929
26930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26931   unsigned int jresult ;
26932   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26933   unsigned int result;
26934
26935   arg1 = (Dali::Gesture *)jarg1;
26936   result = (unsigned int) ((arg1)->time);
26937   jresult = result;
26938   return jresult;
26939 }
26940
26941
26942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26943   void * jresult ;
26944   Dali::HoverEvent *result = 0 ;
26945
26946   {
26947     try {
26948       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26949     } catch (std::out_of_range& e) {
26950       {
26951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26952       };
26953     } catch (std::exception& e) {
26954       {
26955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26956       };
26957     } catch (...) {
26958       {
26959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26960       };
26961     }
26962   }
26963   jresult = (void *)result;
26964   return jresult;
26965 }
26966
26967
26968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26969   void * jresult ;
26970   unsigned long arg1 ;
26971   Dali::HoverEvent *result = 0 ;
26972
26973   arg1 = (unsigned long)jarg1;
26974   {
26975     try {
26976       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26977     } catch (std::out_of_range& e) {
26978       {
26979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26980       };
26981     } catch (std::exception& e) {
26982       {
26983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26984       };
26985     } catch (...) {
26986       {
26987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26988       };
26989     }
26990   }
26991   jresult = (void *)result;
26992   return jresult;
26993 }
26994
26995
26996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
26997   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
26998
26999   arg1 = (Dali::HoverEvent *)jarg1;
27000   {
27001     try {
27002       delete arg1;
27003     } catch (std::out_of_range& e) {
27004       {
27005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27006       };
27007     } catch (std::exception& e) {
27008       {
27009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27010       };
27011     } catch (...) {
27012       {
27013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27014       };
27015     }
27016   }
27017 }
27018
27019
27020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27021   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27022   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27023
27024   arg1 = (Dali::HoverEvent *)jarg1;
27025   arg2 = (Dali::TouchPointContainer *)jarg2;
27026   if (arg1) (arg1)->points = *arg2;
27027 }
27028
27029
27030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27031   void * jresult ;
27032   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27033   Dali::TouchPointContainer *result = 0 ;
27034
27035   arg1 = (Dali::HoverEvent *)jarg1;
27036   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27037   jresult = (void *)result;
27038   return jresult;
27039 }
27040
27041
27042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27043   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27044   unsigned long arg2 ;
27045
27046   arg1 = (Dali::HoverEvent *)jarg1;
27047   arg2 = (unsigned long)jarg2;
27048   if (arg1) (arg1)->time = arg2;
27049 }
27050
27051
27052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27053   unsigned long jresult ;
27054   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27055   unsigned long result;
27056
27057   arg1 = (Dali::HoverEvent *)jarg1;
27058   result = (unsigned long) ((arg1)->time);
27059   jresult = (unsigned long)result;
27060   return jresult;
27061 }
27062
27063
27064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27065   unsigned int jresult ;
27066   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27067   unsigned int result;
27068
27069   arg1 = (Dali::HoverEvent *)jarg1;
27070   {
27071     try {
27072       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27073     } catch (std::out_of_range& e) {
27074       {
27075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27076       };
27077     } catch (std::exception& e) {
27078       {
27079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27080       };
27081     } catch (...) {
27082       {
27083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27084       };
27085     }
27086   }
27087   jresult = result;
27088   return jresult;
27089 }
27090
27091
27092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27093   void * jresult ;
27094   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27095   unsigned int arg2 ;
27096   Dali::TouchPoint *result = 0 ;
27097
27098   arg1 = (Dali::HoverEvent *)jarg1;
27099   arg2 = (unsigned int)jarg2;
27100   {
27101     try {
27102       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27103     } catch (std::out_of_range& e) {
27104       {
27105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27106       };
27107     } catch (std::exception& e) {
27108       {
27109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27110       };
27111     } catch (...) {
27112       {
27113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27114       };
27115     }
27116   }
27117   jresult = (void *)result;
27118   return jresult;
27119 }
27120
27121
27122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27123   void * jresult ;
27124   Dali::KeyEvent *result = 0 ;
27125
27126   {
27127     try {
27128       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27129     } catch (std::out_of_range& e) {
27130       {
27131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27132       };
27133     } catch (std::exception& e) {
27134       {
27135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27136       };
27137     } catch (...) {
27138       {
27139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27140       };
27141     }
27142   }
27143   jresult = (void *)result;
27144   return jresult;
27145 }
27146
27147
27148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27149   void * jresult ;
27150   std::string *arg1 = 0 ;
27151   std::string *arg2 = 0 ;
27152   int arg3 ;
27153   int arg4 ;
27154   unsigned long arg5 ;
27155   Dali::KeyEvent::State *arg6 = 0 ;
27156   Dali::KeyEvent::State temp6 ;
27157   Dali::KeyEvent *result = 0 ;
27158
27159   if (!jarg1) {
27160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27161     return 0;
27162   }
27163   std::string arg1_str(jarg1);
27164   arg1 = &arg1_str;
27165   if (!jarg2) {
27166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27167     return 0;
27168   }
27169   std::string arg2_str(jarg2);
27170   arg2 = &arg2_str;
27171   arg3 = (int)jarg3;
27172   arg4 = (int)jarg4;
27173   arg5 = (unsigned long)jarg5;
27174   temp6 = (Dali::KeyEvent::State)jarg6;
27175   arg6 = &temp6;
27176   {
27177     try {
27178       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27179     } catch (std::out_of_range& e) {
27180       {
27181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27182       };
27183     } catch (std::exception& e) {
27184       {
27185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27186       };
27187     } catch (...) {
27188       {
27189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27190       };
27191     }
27192   }
27193   jresult = (void *)result;
27194
27195   //argout typemap for const std::string&
27196
27197
27198   //argout typemap for const std::string&
27199
27200   return jresult;
27201 }
27202
27203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27204   void * jresult ;
27205   Dali::KeyEvent *arg1 = 0 ;
27206   Dali::KeyEvent *result = 0 ;
27207
27208   arg1 = (Dali::KeyEvent *)jarg1;
27209   if (!arg1) {
27210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27211     return 0;
27212   }
27213   {
27214     try {
27215       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27223       };
27224     } catch (...) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27227       };
27228     }
27229   }
27230   jresult = (void *)result;
27231   return jresult;
27232 }
27233
27234
27235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27236   void * jresult ;
27237   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27238   Dali::KeyEvent *arg2 = 0 ;
27239   Dali::KeyEvent *result = 0 ;
27240
27241   arg1 = (Dali::KeyEvent *)jarg1;
27242   arg2 = (Dali::KeyEvent *)jarg2;
27243   if (!arg2) {
27244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27245     return 0;
27246   }
27247   {
27248     try {
27249       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27250     } catch (std::out_of_range& e) {
27251       {
27252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27253       };
27254     } catch (std::exception& e) {
27255       {
27256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27257       };
27258     } catch (...) {
27259       {
27260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27261       };
27262     }
27263   }
27264   jresult = (void *)result;
27265   return jresult;
27266 }
27267
27268
27269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27270   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27271
27272   arg1 = (Dali::KeyEvent *)jarg1;
27273   {
27274     try {
27275       delete arg1;
27276     } catch (std::out_of_range& e) {
27277       {
27278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27279       };
27280     } catch (std::exception& e) {
27281       {
27282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27283       };
27284     } catch (...) {
27285       {
27286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27287       };
27288     }
27289   }
27290 }
27291
27292
27293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27294   unsigned int jresult ;
27295   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27296   bool result;
27297
27298   arg1 = (Dali::KeyEvent *)jarg1;
27299   {
27300     try {
27301       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27302     } catch (std::out_of_range& e) {
27303       {
27304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27305       };
27306     } catch (std::exception& e) {
27307       {
27308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27309       };
27310     } catch (...) {
27311       {
27312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27313       };
27314     }
27315   }
27316   jresult = result;
27317   return jresult;
27318 }
27319
27320
27321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27322   unsigned int jresult ;
27323   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27324   bool result;
27325
27326   arg1 = (Dali::KeyEvent *)jarg1;
27327   {
27328     try {
27329       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27330     } catch (std::out_of_range& e) {
27331       {
27332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27333       };
27334     } catch (std::exception& e) {
27335       {
27336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27337       };
27338     } catch (...) {
27339       {
27340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27341       };
27342     }
27343   }
27344   jresult = result;
27345   return jresult;
27346 }
27347
27348
27349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27350   unsigned int jresult ;
27351   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27352   bool result;
27353
27354   arg1 = (Dali::KeyEvent *)jarg1;
27355   {
27356     try {
27357       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27369       };
27370     }
27371   }
27372   jresult = result;
27373   return jresult;
27374 }
27375
27376
27377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27378   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27379   std::string *arg2 = 0 ;
27380
27381   arg1 = (Dali::KeyEvent *)jarg1;
27382   if (!jarg2) {
27383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27384     return ;
27385   }
27386   std::string arg2_str(jarg2);
27387   arg2 = &arg2_str;
27388   if (arg1) (arg1)->keyPressedName = *arg2;
27389
27390   //argout typemap for const std::string&
27391
27392 }
27393
27394
27395 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27396   char * jresult ;
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   std::string *result = 0 ;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   result = (std::string *) & ((arg1)->keyPressedName);
27402   jresult = SWIG_csharp_string_callback(result->c_str());
27403   return jresult;
27404 }
27405
27406
27407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27408   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27409   std::string *arg2 = 0 ;
27410
27411   arg1 = (Dali::KeyEvent *)jarg1;
27412   if (!jarg2) {
27413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27414     return ;
27415   }
27416   std::string arg2_str(jarg2);
27417   arg2 = &arg2_str;
27418   if (arg1) (arg1)->keyPressed = *arg2;
27419
27420   //argout typemap for const std::string&
27421
27422 }
27423
27424
27425 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27426   char * jresult ;
27427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27428   std::string *result = 0 ;
27429
27430   arg1 = (Dali::KeyEvent *)jarg1;
27431   result = (std::string *) & ((arg1)->keyPressed);
27432   jresult = SWIG_csharp_string_callback(result->c_str());
27433   return jresult;
27434 }
27435
27436
27437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27438   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27439   int arg2 ;
27440
27441   arg1 = (Dali::KeyEvent *)jarg1;
27442   arg2 = (int)jarg2;
27443   if (arg1) (arg1)->keyCode = arg2;
27444 }
27445
27446
27447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27448   int jresult ;
27449   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27450   int result;
27451
27452   arg1 = (Dali::KeyEvent *)jarg1;
27453   result = (int) ((arg1)->keyCode);
27454   jresult = result;
27455   return jresult;
27456 }
27457
27458
27459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27460   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27461   int arg2 ;
27462
27463   arg1 = (Dali::KeyEvent *)jarg1;
27464   arg2 = (int)jarg2;
27465   if (arg1) (arg1)->keyModifier = arg2;
27466 }
27467
27468
27469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27470   int jresult ;
27471   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27472   int result;
27473
27474   arg1 = (Dali::KeyEvent *)jarg1;
27475   result = (int) ((arg1)->keyModifier);
27476   jresult = result;
27477   return jresult;
27478 }
27479
27480
27481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27482   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27483   unsigned long arg2 ;
27484
27485   arg1 = (Dali::KeyEvent *)jarg1;
27486   arg2 = (unsigned long)jarg2;
27487   if (arg1) (arg1)->time = arg2;
27488 }
27489
27490
27491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27492   unsigned long jresult ;
27493   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27494   unsigned long result;
27495
27496   arg1 = (Dali::KeyEvent *)jarg1;
27497   result = (unsigned long) ((arg1)->time);
27498   jresult = (unsigned long)result;
27499   return jresult;
27500 }
27501
27502
27503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27504   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27505   Dali::KeyEvent::State arg2 ;
27506
27507   arg1 = (Dali::KeyEvent *)jarg1;
27508   arg2 = (Dali::KeyEvent::State)jarg2;
27509   if (arg1) (arg1)->state = arg2;
27510 }
27511
27512
27513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27514   int jresult ;
27515   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27516   Dali::KeyEvent::State result;
27517
27518   arg1 = (Dali::KeyEvent *)jarg1;
27519   result = (Dali::KeyEvent::State) ((arg1)->state);
27520   jresult = (int)result;
27521   return jresult;
27522 }
27523
27524
27525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27526   void * jresult ;
27527   Dali::LongPressGestureDetector *result = 0 ;
27528
27529   {
27530     try {
27531       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27532     } catch (std::out_of_range& e) {
27533       {
27534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27535       };
27536     } catch (std::exception& e) {
27537       {
27538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27539       };
27540     } catch (...) {
27541       {
27542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27543       };
27544     }
27545   }
27546   jresult = (void *)result;
27547   return jresult;
27548 }
27549
27550
27551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27552   void * jresult ;
27553   Dali::LongPressGestureDetector result;
27554
27555   {
27556     try {
27557       result = Dali::LongPressGestureDetector::New();
27558     } catch (std::out_of_range& e) {
27559       {
27560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27561       };
27562     } catch (std::exception& e) {
27563       {
27564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27565       };
27566     } catch (...) {
27567       {
27568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27569       };
27570     }
27571   }
27572   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27573   return jresult;
27574 }
27575
27576
27577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27578   void * jresult ;
27579   unsigned int arg1 ;
27580   Dali::LongPressGestureDetector result;
27581
27582   arg1 = (unsigned int)jarg1;
27583   {
27584     try {
27585       result = Dali::LongPressGestureDetector::New(arg1);
27586     } catch (std::out_of_range& e) {
27587       {
27588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27589       };
27590     } catch (std::exception& e) {
27591       {
27592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27593       };
27594     } catch (...) {
27595       {
27596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27597       };
27598     }
27599   }
27600   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27606   void * jresult ;
27607   unsigned int arg1 ;
27608   unsigned int arg2 ;
27609   Dali::LongPressGestureDetector result;
27610
27611   arg1 = (unsigned int)jarg1;
27612   arg2 = (unsigned int)jarg2;
27613   {
27614     try {
27615       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27616     } catch (std::out_of_range& e) {
27617       {
27618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27619       };
27620     } catch (std::exception& e) {
27621       {
27622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27623       };
27624     } catch (...) {
27625       {
27626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27627       };
27628     }
27629   }
27630   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27631   return jresult;
27632 }
27633
27634
27635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27636   void * jresult ;
27637   Dali::BaseHandle arg1 ;
27638   Dali::BaseHandle *argp1 ;
27639   Dali::LongPressGestureDetector result;
27640
27641   argp1 = (Dali::BaseHandle *)jarg1;
27642   if (!argp1) {
27643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27644     return 0;
27645   }
27646   arg1 = *argp1;
27647   {
27648     try {
27649       result = Dali::LongPressGestureDetector::DownCast(arg1);
27650     } catch (std::out_of_range& e) {
27651       {
27652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27653       };
27654     } catch (std::exception& e) {
27655       {
27656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27657       };
27658     } catch (...) {
27659       {
27660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27661       };
27662     }
27663   }
27664   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27665   return jresult;
27666 }
27667
27668
27669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27670   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27671
27672   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27673   {
27674     try {
27675       delete arg1;
27676     } catch (std::out_of_range& e) {
27677       {
27678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27679       };
27680     } catch (std::exception& e) {
27681       {
27682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27683       };
27684     } catch (...) {
27685       {
27686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27687       };
27688     }
27689   }
27690 }
27691
27692
27693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27694   void * jresult ;
27695   Dali::LongPressGestureDetector *arg1 = 0 ;
27696   Dali::LongPressGestureDetector *result = 0 ;
27697
27698   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27699   if (!arg1) {
27700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27701     return 0;
27702   }
27703   {
27704     try {
27705       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27706     } catch (std::out_of_range& e) {
27707       {
27708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27709       };
27710     } catch (std::exception& e) {
27711       {
27712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27713       };
27714     } catch (...) {
27715       {
27716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27717       };
27718     }
27719   }
27720   jresult = (void *)result;
27721   return jresult;
27722 }
27723
27724
27725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27726   void * jresult ;
27727   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27728   Dali::LongPressGestureDetector *arg2 = 0 ;
27729   Dali::LongPressGestureDetector *result = 0 ;
27730
27731   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27732   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27733   if (!arg2) {
27734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27735     return 0;
27736   }
27737   {
27738     try {
27739       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27740     } catch (std::out_of_range& e) {
27741       {
27742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27743       };
27744     } catch (std::exception& e) {
27745       {
27746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27747       };
27748     } catch (...) {
27749       {
27750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27751       };
27752     }
27753   }
27754   jresult = (void *)result;
27755   return jresult;
27756 }
27757
27758
27759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27760   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27761   unsigned int arg2 ;
27762
27763   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27764   arg2 = (unsigned int)jarg2;
27765   {
27766     try {
27767       (arg1)->SetTouchesRequired(arg2);
27768     } catch (std::out_of_range& e) {
27769       {
27770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27771       };
27772     } catch (std::exception& e) {
27773       {
27774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27779       };
27780     }
27781   }
27782 }
27783
27784
27785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27786   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27787   unsigned int arg2 ;
27788   unsigned int arg3 ;
27789
27790   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27791   arg2 = (unsigned int)jarg2;
27792   arg3 = (unsigned int)jarg3;
27793   {
27794     try {
27795       (arg1)->SetTouchesRequired(arg2,arg3);
27796     } catch (std::out_of_range& e) {
27797       {
27798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27799       };
27800     } catch (std::exception& e) {
27801       {
27802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27803       };
27804     } catch (...) {
27805       {
27806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27807       };
27808     }
27809   }
27810 }
27811
27812
27813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27814   unsigned int jresult ;
27815   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27816   unsigned int result;
27817
27818   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27819   {
27820     try {
27821       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27822     } catch (std::out_of_range& e) {
27823       {
27824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27825       };
27826     } catch (std::exception& e) {
27827       {
27828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27829       };
27830     } catch (...) {
27831       {
27832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27833       };
27834     }
27835   }
27836   jresult = result;
27837   return jresult;
27838 }
27839
27840
27841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27842   unsigned int jresult ;
27843   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27844   unsigned int result;
27845
27846   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27847   {
27848     try {
27849       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27850     } catch (std::out_of_range& e) {
27851       {
27852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27853       };
27854     } catch (std::exception& e) {
27855       {
27856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27857       };
27858     } catch (...) {
27859       {
27860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27861       };
27862     }
27863   }
27864   jresult = result;
27865   return jresult;
27866 }
27867
27868
27869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27870   void * jresult ;
27871   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27872   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27873
27874   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27875   {
27876     try {
27877       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27878     } catch (std::out_of_range& e) {
27879       {
27880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27881       };
27882     } catch (std::exception& e) {
27883       {
27884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27885       };
27886     } catch (...) {
27887       {
27888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27889       };
27890     }
27891   }
27892   jresult = (void *)result;
27893   return jresult;
27894 }
27895
27896
27897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27898   void * jresult ;
27899   Dali::Gesture::State arg1 ;
27900   Dali::LongPressGesture *result = 0 ;
27901
27902   arg1 = (Dali::Gesture::State)jarg1;
27903   {
27904     try {
27905       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27906     } catch (std::out_of_range& e) {
27907       {
27908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (std::exception& e) {
27911       {
27912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920   jresult = (void *)result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27926   void * jresult ;
27927   Dali::LongPressGesture *arg1 = 0 ;
27928   Dali::LongPressGesture *result = 0 ;
27929
27930   arg1 = (Dali::LongPressGesture *)jarg1;
27931   if (!arg1) {
27932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27933     return 0;
27934   }
27935   {
27936     try {
27937       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27938     } catch (std::out_of_range& e) {
27939       {
27940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27941       };
27942     } catch (std::exception& e) {
27943       {
27944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27945       };
27946     } catch (...) {
27947       {
27948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27949       };
27950     }
27951   }
27952   jresult = (void *)result;
27953   return jresult;
27954 }
27955
27956
27957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27958   void * jresult ;
27959   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27960   Dali::LongPressGesture *arg2 = 0 ;
27961   Dali::LongPressGesture *result = 0 ;
27962
27963   arg1 = (Dali::LongPressGesture *)jarg1;
27964   arg2 = (Dali::LongPressGesture *)jarg2;
27965   if (!arg2) {
27966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27967     return 0;
27968   }
27969   {
27970     try {
27971       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27972     } catch (std::out_of_range& e) {
27973       {
27974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27975       };
27976     } catch (std::exception& e) {
27977       {
27978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (...) {
27981       {
27982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27983       };
27984     }
27985   }
27986   jresult = (void *)result;
27987   return jresult;
27988 }
27989
27990
27991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27992   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27993
27994   arg1 = (Dali::LongPressGesture *)jarg1;
27995   {
27996     try {
27997       delete arg1;
27998     } catch (std::out_of_range& e) {
27999       {
28000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28001       };
28002     } catch (std::exception& e) {
28003       {
28004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28005       };
28006     } catch (...) {
28007       {
28008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28009       };
28010     }
28011   }
28012 }
28013
28014
28015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28016   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28017   unsigned int arg2 ;
28018
28019   arg1 = (Dali::LongPressGesture *)jarg1;
28020   arg2 = (unsigned int)jarg2;
28021   if (arg1) (arg1)->numberOfTouches = arg2;
28022 }
28023
28024
28025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28026   unsigned int jresult ;
28027   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28028   unsigned int result;
28029
28030   arg1 = (Dali::LongPressGesture *)jarg1;
28031   result = (unsigned int) ((arg1)->numberOfTouches);
28032   jresult = result;
28033   return jresult;
28034 }
28035
28036
28037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28038   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28039   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28040
28041   arg1 = (Dali::LongPressGesture *)jarg1;
28042   arg2 = (Dali::Vector2 *)jarg2;
28043   if (arg1) (arg1)->screenPoint = *arg2;
28044 }
28045
28046
28047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28048   void * jresult ;
28049   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28050   Dali::Vector2 *result = 0 ;
28051
28052   arg1 = (Dali::LongPressGesture *)jarg1;
28053   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28060   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28061   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28062
28063   arg1 = (Dali::LongPressGesture *)jarg1;
28064   arg2 = (Dali::Vector2 *)jarg2;
28065   if (arg1) (arg1)->localPoint = *arg2;
28066 }
28067
28068
28069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28070   void * jresult ;
28071   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28072   Dali::Vector2 *result = 0 ;
28073
28074   arg1 = (Dali::LongPressGesture *)jarg1;
28075   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28076   jresult = (void *)result;
28077   return jresult;
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28082   void * jresult ;
28083   Dali::WheelEvent *result = 0 ;
28084
28085   {
28086     try {
28087       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28088     } catch (std::out_of_range& e) {
28089       {
28090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28091       };
28092     } catch (std::exception& e) {
28093       {
28094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28095       };
28096     } catch (...) {
28097       {
28098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28099       };
28100     }
28101   }
28102   jresult = (void *)result;
28103   return jresult;
28104 }
28105
28106
28107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28108   void * jresult ;
28109   Dali::WheelEvent::Type arg1 ;
28110   int arg2 ;
28111   unsigned int arg3 ;
28112   Dali::Vector2 arg4 ;
28113   int arg5 ;
28114   unsigned int arg6 ;
28115   Dali::Vector2 *argp4 ;
28116   Dali::WheelEvent *result = 0 ;
28117
28118   arg1 = (Dali::WheelEvent::Type)jarg1;
28119   arg2 = (int)jarg2;
28120   arg3 = (unsigned int)jarg3;
28121   argp4 = (Dali::Vector2 *)jarg4;
28122   if (!argp4) {
28123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28124     return 0;
28125   }
28126   arg4 = *argp4;
28127   arg5 = (int)jarg5;
28128   arg6 = (unsigned int)jarg6;
28129   {
28130     try {
28131       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28132     } catch (std::out_of_range& e) {
28133       {
28134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28135       };
28136     } catch (std::exception& e) {
28137       {
28138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28139       };
28140     } catch (...) {
28141       {
28142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28143       };
28144     }
28145   }
28146   jresult = (void *)result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28152   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28153
28154   arg1 = (Dali::WheelEvent *)jarg1;
28155   {
28156     try {
28157       delete arg1;
28158     } catch (std::out_of_range& e) {
28159       {
28160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28161       };
28162     } catch (std::exception& e) {
28163       {
28164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28165       };
28166     } catch (...) {
28167       {
28168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28169       };
28170     }
28171   }
28172 }
28173
28174
28175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28176   unsigned int jresult ;
28177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28178   bool result;
28179
28180   arg1 = (Dali::WheelEvent *)jarg1;
28181   {
28182     try {
28183       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28184     } catch (std::out_of_range& e) {
28185       {
28186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28187       };
28188     } catch (std::exception& e) {
28189       {
28190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28191       };
28192     } catch (...) {
28193       {
28194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28195       };
28196     }
28197   }
28198   jresult = result;
28199   return jresult;
28200 }
28201
28202
28203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28204   unsigned int jresult ;
28205   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28206   bool result;
28207
28208   arg1 = (Dali::WheelEvent *)jarg1;
28209   {
28210     try {
28211       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28212     } catch (std::out_of_range& e) {
28213       {
28214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28215       };
28216     } catch (std::exception& e) {
28217       {
28218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28219       };
28220     } catch (...) {
28221       {
28222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28223       };
28224     }
28225   }
28226   jresult = result;
28227   return jresult;
28228 }
28229
28230
28231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28232   unsigned int jresult ;
28233   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28234   bool result;
28235
28236   arg1 = (Dali::WheelEvent *)jarg1;
28237   {
28238     try {
28239       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28240     } catch (std::out_of_range& e) {
28241       {
28242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28243       };
28244     } catch (std::exception& e) {
28245       {
28246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28247       };
28248     } catch (...) {
28249       {
28250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28251       };
28252     }
28253   }
28254   jresult = result;
28255   return jresult;
28256 }
28257
28258
28259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28260   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28261   Dali::WheelEvent::Type arg2 ;
28262
28263   arg1 = (Dali::WheelEvent *)jarg1;
28264   arg2 = (Dali::WheelEvent::Type)jarg2;
28265   if (arg1) (arg1)->type = arg2;
28266 }
28267
28268
28269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28270   int jresult ;
28271   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28272   Dali::WheelEvent::Type result;
28273
28274   arg1 = (Dali::WheelEvent *)jarg1;
28275   result = (Dali::WheelEvent::Type) ((arg1)->type);
28276   jresult = (int)result;
28277   return jresult;
28278 }
28279
28280
28281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28282   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28283   int arg2 ;
28284
28285   arg1 = (Dali::WheelEvent *)jarg1;
28286   arg2 = (int)jarg2;
28287   if (arg1) (arg1)->direction = arg2;
28288 }
28289
28290
28291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28292   int jresult ;
28293   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28294   int result;
28295
28296   arg1 = (Dali::WheelEvent *)jarg1;
28297   result = (int) ((arg1)->direction);
28298   jresult = result;
28299   return jresult;
28300 }
28301
28302
28303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28304   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28305   unsigned int arg2 ;
28306
28307   arg1 = (Dali::WheelEvent *)jarg1;
28308   arg2 = (unsigned int)jarg2;
28309   if (arg1) (arg1)->modifiers = arg2;
28310 }
28311
28312
28313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28314   unsigned int jresult ;
28315   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28316   unsigned int result;
28317
28318   arg1 = (Dali::WheelEvent *)jarg1;
28319   result = (unsigned int) ((arg1)->modifiers);
28320   jresult = result;
28321   return jresult;
28322 }
28323
28324
28325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28326   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28327   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28328
28329   arg1 = (Dali::WheelEvent *)jarg1;
28330   arg2 = (Dali::Vector2 *)jarg2;
28331   if (arg1) (arg1)->point = *arg2;
28332 }
28333
28334
28335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28336   void * jresult ;
28337   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28338   Dali::Vector2 *result = 0 ;
28339
28340   arg1 = (Dali::WheelEvent *)jarg1;
28341   result = (Dali::Vector2 *)& ((arg1)->point);
28342   jresult = (void *)result;
28343   return jresult;
28344 }
28345
28346
28347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28348   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28349   int arg2 ;
28350
28351   arg1 = (Dali::WheelEvent *)jarg1;
28352   arg2 = (int)jarg2;
28353   if (arg1) (arg1)->z = arg2;
28354 }
28355
28356
28357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28358   int jresult ;
28359   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28360   int result;
28361
28362   arg1 = (Dali::WheelEvent *)jarg1;
28363   result = (int) ((arg1)->z);
28364   jresult = result;
28365   return jresult;
28366 }
28367
28368
28369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28371   unsigned int arg2 ;
28372
28373   arg1 = (Dali::WheelEvent *)jarg1;
28374   arg2 = (unsigned int)jarg2;
28375   if (arg1) (arg1)->timeStamp = arg2;
28376 }
28377
28378
28379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28380   unsigned int jresult ;
28381   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28382   unsigned int result;
28383
28384   arg1 = (Dali::WheelEvent *)jarg1;
28385   result = (unsigned int) ((arg1)->timeStamp);
28386   jresult = result;
28387   return jresult;
28388 }
28389
28390 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28391   char * jresult ;
28392   Dali::KeyEvent *arg1 = 0 ;
28393   std::string result;
28394
28395   arg1 = (Dali::KeyEvent *)jarg1;
28396   if (!arg1) {
28397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28398     return 0;
28399   }
28400   {
28401     try {
28402       result = arg1->GetDeviceName();
28403     } catch (std::out_of_range& e) {
28404       {
28405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28406       };
28407     } catch (std::exception& e) {
28408       {
28409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28410       };
28411     } catch (...) {
28412       {
28413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28414       };
28415     }
28416   }
28417   jresult = SWIG_csharp_string_callback((&result)->c_str());
28418   return jresult;
28419 }
28420
28421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28422   int jresult ;
28423   Dali::KeyEvent *arg1 = 0 ;
28424   Dali::Device::Class::Type result;
28425
28426   arg1 = (Dali::KeyEvent *)jarg1;
28427   if (!arg1) {
28428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28429     return 0;
28430   }
28431   {
28432     try {
28433       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
28434     } catch (std::out_of_range& e) {
28435       {
28436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28437       };
28438     } catch (std::exception& e) {
28439       {
28440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28441       };
28442     } catch (...) {
28443       {
28444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28445       };
28446     }
28447   }
28448   jresult = (int)result;
28449   return jresult;
28450 }
28451
28452
28453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28454   Dali::Actor arg1 ;
28455   Dali::Actor *argp1 ;
28456
28457   argp1 = (Dali::Actor *)jarg1;
28458   if (!argp1) {
28459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28460     return ;
28461   }
28462   arg1 = *argp1;
28463   {
28464     try {
28465       arg1.Raise();
28466     } catch (std::out_of_range& e) {
28467       {
28468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28469       };
28470     } catch (std::exception& e) {
28471       {
28472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28473       };
28474     } catch (...) {
28475       {
28476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28477       };
28478     }
28479   }
28480 }
28481
28482
28483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28484   Dali::Actor arg1 ;
28485   Dali::Actor *argp1 ;
28486
28487   argp1 = (Dali::Actor *)jarg1;
28488   if (!argp1) {
28489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28490     return ;
28491   }
28492   arg1 = *argp1;
28493   {
28494     try {
28495       arg1.Lower();
28496     } catch (std::out_of_range& e) {
28497       {
28498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28499       };
28500     } catch (std::exception& e) {
28501       {
28502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28503       };
28504     } catch (...) {
28505       {
28506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28507       };
28508     }
28509   }
28510 }
28511
28512
28513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28514   Dali::Actor arg1 ;
28515   Dali::Actor *argp1 ;
28516
28517   argp1 = (Dali::Actor *)jarg1;
28518   if (!argp1) {
28519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28520     return ;
28521   }
28522   arg1 = *argp1;
28523   {
28524     try {
28525       arg1.RaiseToTop();
28526     } catch (std::out_of_range& e) {
28527       {
28528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28529       };
28530     } catch (std::exception& e) {
28531       {
28532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28533       };
28534     } catch (...) {
28535       {
28536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28537       };
28538     }
28539   }
28540 }
28541
28542
28543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28544   Dali::Actor arg1 ;
28545   Dali::Actor *argp1 ;
28546
28547   argp1 = (Dali::Actor *)jarg1;
28548   if (!argp1) {
28549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28550     return ;
28551   }
28552   arg1 = *argp1;
28553   {
28554     try {
28555       arg1.LowerToBottom();
28556     } catch (std::out_of_range& e) {
28557       {
28558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28559       };
28560     } catch (std::exception& e) {
28561       {
28562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28563       };
28564     } catch (...) {
28565       {
28566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28567       };
28568     }
28569   }
28570 }
28571
28572
28573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28574   Dali::Actor arg1 ;
28575   Dali::Actor arg2 ;
28576   Dali::Actor *argp1 ;
28577   Dali::Actor *argp2 ;
28578
28579   argp1 = (Dali::Actor *)jarg1;
28580   if (!argp1) {
28581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28582     return ;
28583   }
28584   arg1 = *argp1;
28585   argp2 = (Dali::Actor *)jarg2;
28586   if (!argp2) {
28587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28588     return ;
28589   }
28590   arg2 = *argp2;
28591   {
28592     try {
28593       arg1.RaiseAbove(arg2);
28594     } catch (std::out_of_range& e) {
28595       {
28596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28597       };
28598     } catch (std::exception& e) {
28599       {
28600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28601       };
28602     } catch (...) {
28603       {
28604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28605       };
28606     }
28607   }
28608 }
28609
28610
28611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28612   Dali::Actor arg1 ;
28613   Dali::Actor arg2 ;
28614   Dali::Actor *argp1 ;
28615   Dali::Actor *argp2 ;
28616
28617   argp1 = (Dali::Actor *)jarg1;
28618   if (!argp1) {
28619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28620     return ;
28621   }
28622   arg1 = *argp1;
28623   argp2 = (Dali::Actor *)jarg2;
28624   if (!argp2) {
28625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28626     return ;
28627   }
28628   arg2 = *argp2;
28629   {
28630     try {
28631       arg1.LowerBelow(arg2);
28632     } catch (std::out_of_range& e) {
28633       {
28634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28635       };
28636     } catch (std::exception& e) {
28637       {
28638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28639       };
28640     } catch (...) {
28641       {
28642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28643       };
28644     }
28645   }
28646 }
28647
28648
28649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28650   void * jresult ;
28651   Dali::Actor arg1 ;
28652   Dali::Actor *argp1 ;
28653   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28654
28655   argp1 = (Dali::Actor *)jarg1;
28656   if (!argp1) {
28657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28658     return 0;
28659   }
28660   arg1 = *argp1;
28661   {
28662     try {
28663       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28664     } catch (std::out_of_range& e) {
28665       {
28666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28667       };
28668     } catch (std::exception& e) {
28669       {
28670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28671       };
28672     } catch (...) {
28673       {
28674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28675       };
28676     }
28677   }
28678   jresult = (void *)result;
28679   return jresult;
28680 }
28681
28682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28683   int jresult ;
28684   int result;
28685
28686   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28687   jresult = (int)result;
28688   return jresult;
28689 }
28690
28691
28692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28693   int jresult ;
28694   int result;
28695
28696   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28697   jresult = (int)result;
28698   return jresult;
28699 }
28700
28701
28702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28703   int jresult ;
28704   int result;
28705
28706   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28707   jresult = (int)result;
28708   return jresult;
28709 }
28710
28711
28712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28713   int jresult ;
28714   int result;
28715
28716   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28717   jresult = (int)result;
28718   return jresult;
28719 }
28720
28721
28722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28723   int jresult ;
28724   int result;
28725
28726   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28727   jresult = (int)result;
28728   return jresult;
28729 }
28730
28731
28732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28733   int jresult ;
28734   int result;
28735
28736   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28737   jresult = (int)result;
28738   return jresult;
28739 }
28740
28741
28742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28743   int jresult ;
28744   int result;
28745
28746   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28747   jresult = (int)result;
28748   return jresult;
28749 }
28750
28751
28752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28753   int jresult ;
28754   int result;
28755
28756   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28757   jresult = (int)result;
28758   return jresult;
28759 }
28760
28761
28762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28763   int jresult ;
28764   int result;
28765
28766   result = (int)Dali::Actor::Property::SIZE;
28767   jresult = (int)result;
28768   return jresult;
28769 }
28770
28771
28772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28773   int jresult ;
28774   int result;
28775
28776   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28777   jresult = (int)result;
28778   return jresult;
28779 }
28780
28781
28782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28783   int jresult ;
28784   int result;
28785
28786   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28787   jresult = (int)result;
28788   return jresult;
28789 }
28790
28791
28792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28793   int jresult ;
28794   int result;
28795
28796   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28797   jresult = (int)result;
28798   return jresult;
28799 }
28800
28801
28802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28803   int jresult ;
28804   int result;
28805
28806   result = (int)Dali::Actor::Property::POSITION;
28807   jresult = (int)result;
28808   return jresult;
28809 }
28810
28811
28812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28813   int jresult ;
28814   int result;
28815
28816   result = (int)Dali::Actor::Property::POSITION_X;
28817   jresult = (int)result;
28818   return jresult;
28819 }
28820
28821
28822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28823   int jresult ;
28824   int result;
28825
28826   result = (int)Dali::Actor::Property::POSITION_Y;
28827   jresult = (int)result;
28828   return jresult;
28829 }
28830
28831
28832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28833   int jresult ;
28834   int result;
28835
28836   result = (int)Dali::Actor::Property::POSITION_Z;
28837   jresult = (int)result;
28838   return jresult;
28839 }
28840
28841
28842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28843   int jresult ;
28844   int result;
28845
28846   result = (int)Dali::Actor::Property::WORLD_POSITION;
28847   jresult = (int)result;
28848   return jresult;
28849 }
28850
28851
28852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28853   int jresult ;
28854   int result;
28855
28856   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28857   jresult = (int)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28863   int jresult ;
28864   int result;
28865
28866   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28867   jresult = (int)result;
28868   return jresult;
28869 }
28870
28871
28872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28873   int jresult ;
28874   int result;
28875
28876   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28877   jresult = (int)result;
28878   return jresult;
28879 }
28880
28881
28882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28883   int jresult ;
28884   int result;
28885
28886   result = (int)Dali::Actor::Property::ORIENTATION;
28887   jresult = (int)result;
28888   return jresult;
28889 }
28890
28891
28892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28893   int jresult ;
28894   int result;
28895
28896   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28897   jresult = (int)result;
28898   return jresult;
28899 }
28900
28901
28902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28903   int jresult ;
28904   int result;
28905
28906   result = (int)Dali::Actor::Property::SCALE;
28907   jresult = (int)result;
28908   return jresult;
28909 }
28910
28911
28912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28913   int jresult ;
28914   int result;
28915
28916   result = (int)Dali::Actor::Property::SCALE_X;
28917   jresult = (int)result;
28918   return jresult;
28919 }
28920
28921
28922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28923   int jresult ;
28924   int result;
28925
28926   result = (int)Dali::Actor::Property::SCALE_Y;
28927   jresult = (int)result;
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28933   int jresult ;
28934   int result;
28935
28936   result = (int)Dali::Actor::Property::SCALE_Z;
28937   jresult = (int)result;
28938   return jresult;
28939 }
28940
28941
28942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28943   int jresult ;
28944   int result;
28945
28946   result = (int)Dali::Actor::Property::WORLD_SCALE;
28947   jresult = (int)result;
28948   return jresult;
28949 }
28950
28951
28952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28953   int jresult ;
28954   int result;
28955
28956   result = (int)Dali::Actor::Property::VISIBLE;
28957   jresult = (int)result;
28958   return jresult;
28959 }
28960
28961
28962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28963   int jresult ;
28964   int result;
28965
28966   result = (int)Dali::Actor::Property::COLOR;
28967   jresult = (int)result;
28968   return jresult;
28969 }
28970
28971
28972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28973   int jresult ;
28974   int result;
28975
28976   result = (int)Dali::Actor::Property::COLOR_RED;
28977   jresult = (int)result;
28978   return jresult;
28979 }
28980
28981
28982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28983   int jresult ;
28984   int result;
28985
28986   result = (int)Dali::Actor::Property::COLOR_GREEN;
28987   jresult = (int)result;
28988   return jresult;
28989 }
28990
28991
28992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28993   int jresult ;
28994   int result;
28995
28996   result = (int)Dali::Actor::Property::COLOR_BLUE;
28997   jresult = (int)result;
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29003   int jresult ;
29004   int result;
29005
29006   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29007   jresult = (int)result;
29008   return jresult;
29009 }
29010
29011
29012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29013   int jresult ;
29014   int result;
29015
29016   result = (int)Dali::Actor::Property::WORLD_COLOR;
29017   jresult = (int)result;
29018   return jresult;
29019 }
29020
29021
29022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29023   int jresult ;
29024   int result;
29025
29026   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29027   jresult = (int)result;
29028   return jresult;
29029 }
29030
29031
29032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29033   int jresult ;
29034   int result;
29035
29036   result = (int)Dali::Actor::Property::NAME;
29037   jresult = (int)result;
29038   return jresult;
29039 }
29040
29041
29042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29043   int jresult ;
29044   int result;
29045
29046   result = (int)Dali::Actor::Property::SENSITIVE;
29047   jresult = (int)result;
29048   return jresult;
29049 }
29050
29051
29052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29053   int jresult ;
29054   int result;
29055
29056   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29057   jresult = (int)result;
29058   return jresult;
29059 }
29060
29061
29062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29063   int jresult ;
29064   int result;
29065
29066   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29067   jresult = (int)result;
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29073   int jresult ;
29074   int result;
29075
29076   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29077   jresult = (int)result;
29078   return jresult;
29079 }
29080
29081
29082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29083   int jresult ;
29084   int result;
29085
29086   result = (int)Dali::Actor::Property::COLOR_MODE;
29087   jresult = (int)result;
29088   return jresult;
29089 }
29090
29091
29092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29093   int jresult ;
29094   int result;
29095
29096   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29097   jresult = (int)result;
29098   return jresult;
29099 }
29100
29101
29102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29103   int jresult ;
29104   int result;
29105
29106   result = (int)Dali::Actor::Property::DRAW_MODE;
29107   jresult = (int)result;
29108   return jresult;
29109 }
29110
29111
29112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29113   int jresult ;
29114   int result;
29115
29116   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29117   jresult = (int)result;
29118   return jresult;
29119 }
29120
29121
29122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29123   int jresult ;
29124   int result;
29125
29126   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29127   jresult = (int)result;
29128   return jresult;
29129 }
29130
29131
29132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29133   int jresult ;
29134   int result;
29135
29136   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29137   jresult = (int)result;
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29143   int jresult ;
29144   int result;
29145
29146   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29147   jresult = (int)result;
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29153   int jresult ;
29154   int result;
29155
29156   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29157   jresult = (int)result;
29158   return jresult;
29159 }
29160
29161
29162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29163   int jresult ;
29164   int result;
29165
29166   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29167   jresult = (int)result;
29168   return jresult;
29169 }
29170
29171
29172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29173   int jresult ;
29174   int result;
29175
29176   result = (int)Dali::Actor::Property::PADDING;
29177   jresult = (int)result;
29178   return jresult;
29179 }
29180
29181
29182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29183   int jresult ;
29184   int result;
29185
29186   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29187   jresult = (int)result;
29188   return jresult;
29189 }
29190
29191
29192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29193   int jresult ;
29194   int result;
29195
29196   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29197   jresult = (int)result;
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29203   int jresult ;
29204   int result;
29205
29206   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29207   jresult = (int)result;
29208   return jresult;
29209 }
29210
29211
29212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29213   int jresult ;
29214   int result;
29215
29216   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29217   jresult = (int)result;
29218   return jresult;
29219 }
29220
29221
29222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29223   void * jresult ;
29224   Dali::Actor::Property *result = 0 ;
29225
29226   {
29227     try {
29228       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29229     } catch (std::out_of_range& e) {
29230       {
29231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29232       };
29233     } catch (std::exception& e) {
29234       {
29235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29236       };
29237     } catch (...) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29240       };
29241     }
29242   }
29243   jresult = (void *)result;
29244   return jresult;
29245 }
29246
29247
29248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29249   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29250
29251   arg1 = (Dali::Actor::Property *)jarg1;
29252   {
29253     try {
29254       delete arg1;
29255     } catch (std::out_of_range& e) {
29256       {
29257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29258       };
29259     } catch (std::exception& e) {
29260       {
29261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29262       };
29263     } catch (...) {
29264       {
29265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29266       };
29267     }
29268   }
29269 }
29270
29271
29272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29273   void * jresult ;
29274   Dali::Actor *result = 0 ;
29275
29276   {
29277     try {
29278       result = (Dali::Actor *)new Dali::Actor();
29279     } catch (std::out_of_range& e) {
29280       {
29281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29282       };
29283     } catch (std::exception& e) {
29284       {
29285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29286       };
29287     } catch (...) {
29288       {
29289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29290       };
29291     }
29292   }
29293   jresult = (void *)result;
29294   return jresult;
29295 }
29296
29297
29298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29299   void * jresult ;
29300   Dali::Actor result;
29301
29302   {
29303     try {
29304       result = Dali::Actor::New();
29305     } catch (std::out_of_range& e) {
29306       {
29307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29308       };
29309     } catch (std::exception& e) {
29310       {
29311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29312       };
29313     } catch (...) {
29314       {
29315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29316       };
29317     }
29318   }
29319   jresult = new Dali::Actor((const Dali::Actor &)result);
29320   return jresult;
29321 }
29322
29323
29324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29325   void * jresult ;
29326   Dali::BaseHandle arg1 ;
29327   Dali::BaseHandle *argp1 ;
29328   Dali::Actor result;
29329
29330   argp1 = (Dali::BaseHandle *)jarg1;
29331   if (!argp1) {
29332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29333     return 0;
29334   }
29335   arg1 = *argp1;
29336   {
29337     try {
29338       result = Dali::Actor::DownCast(arg1);
29339     } catch (std::out_of_range& e) {
29340       {
29341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29342       };
29343     } catch (std::exception& e) {
29344       {
29345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29346       };
29347     } catch (...) {
29348       {
29349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29350       };
29351     }
29352   }
29353   jresult = new Dali::Actor((const Dali::Actor &)result);
29354   return jresult;
29355 }
29356
29357
29358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29360
29361   arg1 = (Dali::Actor *)jarg1;
29362   {
29363     try {
29364       delete arg1;
29365     } catch (std::out_of_range& e) {
29366       {
29367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29368       };
29369     } catch (std::exception& e) {
29370       {
29371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29372       };
29373     } catch (...) {
29374       {
29375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29376       };
29377     }
29378   }
29379 }
29380
29381
29382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29383   void * jresult ;
29384   Dali::Actor *arg1 = 0 ;
29385   Dali::Actor *result = 0 ;
29386
29387   arg1 = (Dali::Actor *)jarg1;
29388   if (!arg1) {
29389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29390     return 0;
29391   }
29392   {
29393     try {
29394       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29395     } catch (std::out_of_range& e) {
29396       {
29397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29398       };
29399     } catch (std::exception& e) {
29400       {
29401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29402       };
29403     } catch (...) {
29404       {
29405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29406       };
29407     }
29408   }
29409   jresult = (void *)result;
29410   return jresult;
29411 }
29412
29413
29414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29415   void * jresult ;
29416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29417   Dali::Actor *arg2 = 0 ;
29418   Dali::Actor *result = 0 ;
29419
29420   arg1 = (Dali::Actor *)jarg1;
29421   arg2 = (Dali::Actor *)jarg2;
29422   if (!arg2) {
29423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29424     return 0;
29425   }
29426   {
29427     try {
29428       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29429     } catch (std::out_of_range& e) {
29430       {
29431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29432       };
29433     } catch (std::exception& e) {
29434       {
29435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29436       };
29437     } catch (...) {
29438       {
29439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29440       };
29441     }
29442   }
29443   jresult = (void *)result;
29444   return jresult;
29445 }
29446
29447
29448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29449   char * jresult ;
29450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29451   std::string *result = 0 ;
29452
29453   arg1 = (Dali::Actor *)jarg1;
29454   {
29455     try {
29456       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29457     } catch (std::out_of_range& e) {
29458       {
29459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29460       };
29461     } catch (std::exception& e) {
29462       {
29463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29464       };
29465     } catch (...) {
29466       {
29467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29468       };
29469     }
29470   }
29471   jresult = SWIG_csharp_string_callback(result->c_str());
29472   return jresult;
29473 }
29474
29475
29476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29478   std::string *arg2 = 0 ;
29479
29480   arg1 = (Dali::Actor *)jarg1;
29481   if (!jarg2) {
29482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29483     return ;
29484   }
29485   std::string arg2_str(jarg2);
29486   arg2 = &arg2_str;
29487   {
29488     try {
29489       (arg1)->SetName((std::string const &)*arg2);
29490     } catch (std::out_of_range& e) {
29491       {
29492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29493       };
29494     } catch (std::exception& e) {
29495       {
29496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29497       };
29498     } catch (...) {
29499       {
29500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29501       };
29502     }
29503   }
29504
29505   //argout typemap for const std::string&
29506
29507 }
29508
29509
29510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29511   unsigned int jresult ;
29512   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29513   unsigned int result;
29514
29515   arg1 = (Dali::Actor *)jarg1;
29516   {
29517     try {
29518       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29519     } catch (std::out_of_range& e) {
29520       {
29521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29522       };
29523     } catch (std::exception& e) {
29524       {
29525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29526       };
29527     } catch (...) {
29528       {
29529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29530       };
29531     }
29532   }
29533   jresult = result;
29534   return jresult;
29535 }
29536
29537
29538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29539   unsigned int jresult ;
29540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29541   bool result;
29542
29543   arg1 = (Dali::Actor *)jarg1;
29544   {
29545     try {
29546       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29547     } catch (std::out_of_range& e) {
29548       {
29549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29550       };
29551     } catch (std::exception& e) {
29552       {
29553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29554       };
29555     } catch (...) {
29556       {
29557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29558       };
29559     }
29560   }
29561   jresult = result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29567   unsigned int jresult ;
29568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29569   bool result;
29570
29571   arg1 = (Dali::Actor *)jarg1;
29572   {
29573     try {
29574       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29575     } catch (std::out_of_range& e) {
29576       {
29577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29578       };
29579     } catch (std::exception& e) {
29580       {
29581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29582       };
29583     } catch (...) {
29584       {
29585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29586       };
29587     }
29588   }
29589   jresult = result;
29590   return jresult;
29591 }
29592
29593
29594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29595   unsigned int jresult ;
29596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29597   bool result;
29598
29599   arg1 = (Dali::Actor *)jarg1;
29600   {
29601     try {
29602       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29603     } catch (std::out_of_range& e) {
29604       {
29605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29606       };
29607     } catch (std::exception& e) {
29608       {
29609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29610       };
29611     } catch (...) {
29612       {
29613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29614       };
29615     }
29616   }
29617   jresult = result;
29618   return jresult;
29619 }
29620
29621
29622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29623   void * jresult ;
29624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29625   Dali::Layer result;
29626
29627   arg1 = (Dali::Actor *)jarg1;
29628   {
29629     try {
29630       result = (arg1)->GetLayer();
29631     } catch (std::out_of_range& e) {
29632       {
29633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29634       };
29635     } catch (std::exception& e) {
29636       {
29637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29638       };
29639     } catch (...) {
29640       {
29641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29642       };
29643     }
29644   }
29645   jresult = new Dali::Layer((const Dali::Layer &)result);
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29652   Dali::Actor arg2 ;
29653   Dali::Actor *argp2 ;
29654
29655   arg1 = (Dali::Actor *)jarg1;
29656   argp2 = (Dali::Actor *)jarg2;
29657   if (!argp2) {
29658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29659     return ;
29660   }
29661   arg2 = *argp2;
29662   {
29663     try {
29664       (arg1)->Add(arg2);
29665     } catch (std::out_of_range& e) {
29666       {
29667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29668       };
29669     } catch (std::exception& e) {
29670       {
29671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29672       };
29673     } catch (...) {
29674       {
29675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29676       };
29677     }
29678   }
29679 }
29680
29681
29682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29684   Dali::Actor arg2 ;
29685   Dali::Actor *argp2 ;
29686
29687   arg1 = (Dali::Actor *)jarg1;
29688   argp2 = (Dali::Actor *)jarg2;
29689   if (!argp2) {
29690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29691     return ;
29692   }
29693   arg2 = *argp2;
29694   {
29695     try {
29696       (arg1)->Remove(arg2);
29697     } catch (std::out_of_range& e) {
29698       {
29699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29700       };
29701     } catch (std::exception& e) {
29702       {
29703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29704       };
29705     } catch (...) {
29706       {
29707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29708       };
29709     }
29710   }
29711 }
29712
29713
29714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29716
29717   arg1 = (Dali::Actor *)jarg1;
29718   {
29719     try {
29720       (arg1)->Unparent();
29721     } catch (std::out_of_range& e) {
29722       {
29723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29724       };
29725     } catch (std::exception& e) {
29726       {
29727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29728       };
29729     } catch (...) {
29730       {
29731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29732       };
29733     }
29734   }
29735 }
29736
29737
29738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29739   unsigned int jresult ;
29740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29741   unsigned int result;
29742
29743   arg1 = (Dali::Actor *)jarg1;
29744   {
29745     try {
29746       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29747     } catch (std::out_of_range& e) {
29748       {
29749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29750       };
29751     } catch (std::exception& e) {
29752       {
29753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29754       };
29755     } catch (...) {
29756       {
29757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29758       };
29759     }
29760   }
29761   jresult = result;
29762   return jresult;
29763 }
29764
29765
29766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29767   void * jresult ;
29768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29769   unsigned int arg2 ;
29770   Dali::Actor result;
29771
29772   arg1 = (Dali::Actor *)jarg1;
29773   arg2 = (unsigned int)jarg2;
29774   {
29775     try {
29776       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29777     } catch (std::out_of_range& e) {
29778       {
29779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29780       };
29781     } catch (std::exception& e) {
29782       {
29783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29784       };
29785     } catch (...) {
29786       {
29787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29788       };
29789     }
29790   }
29791   jresult = new Dali::Actor((const Dali::Actor &)result);
29792   return jresult;
29793 }
29794
29795
29796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29797   void * jresult ;
29798   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29799   std::string *arg2 = 0 ;
29800   Dali::Actor result;
29801
29802   arg1 = (Dali::Actor *)jarg1;
29803   if (!jarg2) {
29804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29805     return 0;
29806   }
29807   std::string arg2_str(jarg2);
29808   arg2 = &arg2_str;
29809   {
29810     try {
29811       result = (arg1)->FindChildByName((std::string const &)*arg2);
29812     } catch (std::out_of_range& e) {
29813       {
29814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (std::exception& e) {
29817       {
29818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29823       };
29824     }
29825   }
29826   jresult = new Dali::Actor((const Dali::Actor &)result);
29827
29828   //argout typemap for const std::string&
29829
29830   return jresult;
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29835   void * jresult ;
29836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29837   unsigned int arg2 ;
29838   Dali::Actor result;
29839
29840   arg1 = (Dali::Actor *)jarg1;
29841   arg2 = (unsigned int)jarg2;
29842   {
29843     try {
29844       result = (arg1)->FindChildById(arg2);
29845     } catch (std::out_of_range& e) {
29846       {
29847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29848       };
29849     } catch (std::exception& e) {
29850       {
29851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (...) {
29854       {
29855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29856       };
29857     }
29858   }
29859   jresult = new Dali::Actor((const Dali::Actor &)result);
29860   return jresult;
29861 }
29862
29863
29864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29865   void * jresult ;
29866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29867   Dali::Actor result;
29868
29869   arg1 = (Dali::Actor *)jarg1;
29870   {
29871     try {
29872       result = ((Dali::Actor const *)arg1)->GetParent();
29873     } catch (std::out_of_range& e) {
29874       {
29875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29876       };
29877     } catch (std::exception& e) {
29878       {
29879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29880       };
29881     } catch (...) {
29882       {
29883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29884       };
29885     }
29886   }
29887   jresult = new Dali::Actor((const Dali::Actor &)result);
29888   return jresult;
29889 }
29890
29891
29892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29894   Dali::Vector3 *arg2 = 0 ;
29895
29896   arg1 = (Dali::Actor *)jarg1;
29897   arg2 = (Dali::Vector3 *)jarg2;
29898   if (!arg2) {
29899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29900     return ;
29901   }
29902   {
29903     try {
29904       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29905     } catch (std::out_of_range& e) {
29906       {
29907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29908       };
29909     } catch (std::exception& e) {
29910       {
29911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29912       };
29913     } catch (...) {
29914       {
29915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29916       };
29917     }
29918   }
29919 }
29920
29921
29922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29923   void * jresult ;
29924   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29925   Dali::Vector3 result;
29926
29927   arg1 = (Dali::Actor *)jarg1;
29928   {
29929     try {
29930       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29931     } catch (std::out_of_range& e) {
29932       {
29933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29934       };
29935     } catch (std::exception& e) {
29936       {
29937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29938       };
29939     } catch (...) {
29940       {
29941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29942       };
29943     }
29944   }
29945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29946   return jresult;
29947 }
29948
29949
29950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29952   Dali::Vector3 *arg2 = 0 ;
29953
29954   arg1 = (Dali::Actor *)jarg1;
29955   arg2 = (Dali::Vector3 *)jarg2;
29956   if (!arg2) {
29957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29958     return ;
29959   }
29960   {
29961     try {
29962       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29963     } catch (std::out_of_range& e) {
29964       {
29965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29966       };
29967     } catch (std::exception& e) {
29968       {
29969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29970       };
29971     } catch (...) {
29972       {
29973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29974       };
29975     }
29976   }
29977 }
29978
29979
29980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29981   void * jresult ;
29982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29983   Dali::Vector3 result;
29984
29985   arg1 = (Dali::Actor *)jarg1;
29986   {
29987     try {
29988       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29989     } catch (std::out_of_range& e) {
29990       {
29991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29992       };
29993     } catch (std::exception& e) {
29994       {
29995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29996       };
29997     } catch (...) {
29998       {
29999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30000       };
30001     }
30002   }
30003   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30004   return jresult;
30005 }
30006
30007
30008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30010   float arg2 ;
30011   float arg3 ;
30012
30013   arg1 = (Dali::Actor *)jarg1;
30014   arg2 = (float)jarg2;
30015   arg3 = (float)jarg3;
30016   {
30017     try {
30018       (arg1)->SetSize(arg2,arg3);
30019     } catch (std::out_of_range& e) {
30020       {
30021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30022       };
30023     } catch (std::exception& e) {
30024       {
30025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30026       };
30027     } catch (...) {
30028       {
30029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30030       };
30031     }
30032   }
30033 }
30034
30035
30036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30037   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30038   float arg2 ;
30039   float arg3 ;
30040   float arg4 ;
30041
30042   arg1 = (Dali::Actor *)jarg1;
30043   arg2 = (float)jarg2;
30044   arg3 = (float)jarg3;
30045   arg4 = (float)jarg4;
30046   {
30047     try {
30048       (arg1)->SetSize(arg2,arg3,arg4);
30049     } catch (std::out_of_range& e) {
30050       {
30051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30052       };
30053     } catch (std::exception& e) {
30054       {
30055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30056       };
30057     } catch (...) {
30058       {
30059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30060       };
30061     }
30062   }
30063 }
30064
30065
30066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30068   Dali::Vector2 *arg2 = 0 ;
30069
30070   arg1 = (Dali::Actor *)jarg1;
30071   arg2 = (Dali::Vector2 *)jarg2;
30072   if (!arg2) {
30073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30074     return ;
30075   }
30076   {
30077     try {
30078       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30079     } catch (std::out_of_range& e) {
30080       {
30081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30082       };
30083     } catch (std::exception& e) {
30084       {
30085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30086       };
30087     } catch (...) {
30088       {
30089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30090       };
30091     }
30092   }
30093 }
30094
30095
30096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30098   Dali::Vector3 *arg2 = 0 ;
30099
30100   arg1 = (Dali::Actor *)jarg1;
30101   arg2 = (Dali::Vector3 *)jarg2;
30102   if (!arg2) {
30103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30104     return ;
30105   }
30106   {
30107     try {
30108       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30109     } catch (std::out_of_range& e) {
30110       {
30111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30112       };
30113     } catch (std::exception& e) {
30114       {
30115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30116       };
30117     } catch (...) {
30118       {
30119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30120       };
30121     }
30122   }
30123 }
30124
30125
30126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30127   void * jresult ;
30128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30129   Dali::Vector3 result;
30130
30131   arg1 = (Dali::Actor *)jarg1;
30132   {
30133     try {
30134       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30135     } catch (std::out_of_range& e) {
30136       {
30137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30138       };
30139     } catch (std::exception& e) {
30140       {
30141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30142       };
30143     } catch (...) {
30144       {
30145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30146       };
30147     }
30148   }
30149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30150   return jresult;
30151 }
30152
30153
30154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30155   void * jresult ;
30156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30157   Dali::Vector3 result;
30158
30159   arg1 = (Dali::Actor *)jarg1;
30160   {
30161     try {
30162       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30163     } catch (std::out_of_range& e) {
30164       {
30165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30166       };
30167     } catch (std::exception& e) {
30168       {
30169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30170       };
30171     } catch (...) {
30172       {
30173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30174       };
30175     }
30176   }
30177   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30178   return jresult;
30179 }
30180
30181
30182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30183   void * jresult ;
30184   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30185   Dali::Vector3 result;
30186
30187   arg1 = (Dali::Actor *)jarg1;
30188   {
30189     try {
30190       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30191     } catch (std::out_of_range& e) {
30192       {
30193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30194       };
30195     } catch (std::exception& e) {
30196       {
30197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30198       };
30199     } catch (...) {
30200       {
30201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30202       };
30203     }
30204   }
30205   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30206   return jresult;
30207 }
30208
30209
30210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30212   float arg2 ;
30213   float arg3 ;
30214
30215   arg1 = (Dali::Actor *)jarg1;
30216   arg2 = (float)jarg2;
30217   arg3 = (float)jarg3;
30218   {
30219     try {
30220       (arg1)->SetPosition(arg2,arg3);
30221     } catch (std::out_of_range& e) {
30222       {
30223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30224       };
30225     } catch (std::exception& e) {
30226       {
30227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30228       };
30229     } catch (...) {
30230       {
30231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30232       };
30233     }
30234   }
30235 }
30236
30237
30238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30239   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30240   float arg2 ;
30241   float arg3 ;
30242   float arg4 ;
30243
30244   arg1 = (Dali::Actor *)jarg1;
30245   arg2 = (float)jarg2;
30246   arg3 = (float)jarg3;
30247   arg4 = (float)jarg4;
30248   {
30249     try {
30250       (arg1)->SetPosition(arg2,arg3,arg4);
30251     } catch (std::out_of_range& e) {
30252       {
30253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30254       };
30255     } catch (std::exception& e) {
30256       {
30257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30258       };
30259     } catch (...) {
30260       {
30261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30262       };
30263     }
30264   }
30265 }
30266
30267
30268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30270   Dali::Vector3 *arg2 = 0 ;
30271
30272   arg1 = (Dali::Actor *)jarg1;
30273   arg2 = (Dali::Vector3 *)jarg2;
30274   if (!arg2) {
30275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30276     return ;
30277   }
30278   {
30279     try {
30280       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30281     } catch (std::out_of_range& e) {
30282       {
30283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30284       };
30285     } catch (std::exception& e) {
30286       {
30287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30288       };
30289     } catch (...) {
30290       {
30291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30292       };
30293     }
30294   }
30295 }
30296
30297
30298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30300   float arg2 ;
30301
30302   arg1 = (Dali::Actor *)jarg1;
30303   arg2 = (float)jarg2;
30304   {
30305     try {
30306       (arg1)->SetX(arg2);
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30314       };
30315     } catch (...) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30318       };
30319     }
30320   }
30321 }
30322
30323
30324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30326   float arg2 ;
30327
30328   arg1 = (Dali::Actor *)jarg1;
30329   arg2 = (float)jarg2;
30330   {
30331     try {
30332       (arg1)->SetY(arg2);
30333     } catch (std::out_of_range& e) {
30334       {
30335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30336       };
30337     } catch (std::exception& e) {
30338       {
30339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30340       };
30341     } catch (...) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30344       };
30345     }
30346   }
30347 }
30348
30349
30350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30352   float arg2 ;
30353
30354   arg1 = (Dali::Actor *)jarg1;
30355   arg2 = (float)jarg2;
30356   {
30357     try {
30358       (arg1)->SetZ(arg2);
30359     } catch (std::out_of_range& e) {
30360       {
30361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30362       };
30363     } catch (std::exception& e) {
30364       {
30365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30366       };
30367     } catch (...) {
30368       {
30369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30370       };
30371     }
30372   }
30373 }
30374
30375
30376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30378   Dali::Vector3 *arg2 = 0 ;
30379
30380   arg1 = (Dali::Actor *)jarg1;
30381   arg2 = (Dali::Vector3 *)jarg2;
30382   if (!arg2) {
30383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30384     return ;
30385   }
30386   {
30387     try {
30388       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30389     } catch (std::out_of_range& e) {
30390       {
30391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30392       };
30393     } catch (std::exception& e) {
30394       {
30395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30396       };
30397     } catch (...) {
30398       {
30399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30400       };
30401     }
30402   }
30403 }
30404
30405
30406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30407   void * jresult ;
30408   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30409   Dali::Vector3 result;
30410
30411   arg1 = (Dali::Actor *)jarg1;
30412   {
30413     try {
30414       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30415     } catch (std::out_of_range& e) {
30416       {
30417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30418       };
30419     } catch (std::exception& e) {
30420       {
30421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30422       };
30423     } catch (...) {
30424       {
30425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30426       };
30427     }
30428   }
30429   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30430   return jresult;
30431 }
30432
30433
30434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30435   void * jresult ;
30436   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30437   Dali::Vector3 result;
30438
30439   arg1 = (Dali::Actor *)jarg1;
30440   {
30441     try {
30442       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30443     } catch (std::out_of_range& e) {
30444       {
30445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30446       };
30447     } catch (std::exception& e) {
30448       {
30449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30450       };
30451     } catch (...) {
30452       {
30453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30454       };
30455     }
30456   }
30457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30458   return jresult;
30459 }
30460
30461
30462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30464   bool arg2 ;
30465
30466   arg1 = (Dali::Actor *)jarg1;
30467   arg2 = jarg2 ? true : false;
30468   {
30469     try {
30470       (arg1)->SetInheritPosition(arg2);
30471     } catch (std::out_of_range& e) {
30472       {
30473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30474       };
30475     } catch (std::exception& e) {
30476       {
30477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30478       };
30479     } catch (...) {
30480       {
30481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30482       };
30483     }
30484   }
30485 }
30486
30487
30488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30489   int jresult ;
30490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30491   Dali::PositionInheritanceMode result;
30492
30493   arg1 = (Dali::Actor *)jarg1;
30494   {
30495     try {
30496       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30497     } catch (std::out_of_range& e) {
30498       {
30499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30500       };
30501     } catch (std::exception& e) {
30502       {
30503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30504       };
30505     } catch (...) {
30506       {
30507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30508       };
30509     }
30510   }
30511   jresult = (int)result;
30512   return jresult;
30513 }
30514
30515
30516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30517   unsigned int jresult ;
30518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30519   bool result;
30520
30521   arg1 = (Dali::Actor *)jarg1;
30522   {
30523     try {
30524       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30525     } catch (std::out_of_range& e) {
30526       {
30527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30528       };
30529     } catch (std::exception& e) {
30530       {
30531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30532       };
30533     } catch (...) {
30534       {
30535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30536       };
30537     }
30538   }
30539   jresult = result;
30540   return jresult;
30541 }
30542
30543
30544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30545   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30546   Dali::Degree *arg2 = 0 ;
30547   Dali::Vector3 *arg3 = 0 ;
30548
30549   arg1 = (Dali::Actor *)jarg1;
30550   arg2 = (Dali::Degree *)jarg2;
30551   if (!arg2) {
30552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30553     return ;
30554   }
30555   arg3 = (Dali::Vector3 *)jarg3;
30556   if (!arg3) {
30557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30558     return ;
30559   }
30560   {
30561     try {
30562       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30563     } catch (std::out_of_range& e) {
30564       {
30565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30566       };
30567     } catch (std::exception& e) {
30568       {
30569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30570       };
30571     } catch (...) {
30572       {
30573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30574       };
30575     }
30576   }
30577 }
30578
30579
30580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30582   Dali::Radian *arg2 = 0 ;
30583   Dali::Vector3 *arg3 = 0 ;
30584
30585   arg1 = (Dali::Actor *)jarg1;
30586   arg2 = (Dali::Radian *)jarg2;
30587   if (!arg2) {
30588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30589     return ;
30590   }
30591   arg3 = (Dali::Vector3 *)jarg3;
30592   if (!arg3) {
30593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30594     return ;
30595   }
30596   {
30597     try {
30598       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30606       };
30607     } catch (...) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30610       };
30611     }
30612   }
30613 }
30614
30615
30616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30618   Dali::Quaternion *arg2 = 0 ;
30619
30620   arg1 = (Dali::Actor *)jarg1;
30621   arg2 = (Dali::Quaternion *)jarg2;
30622   if (!arg2) {
30623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30624     return ;
30625   }
30626   {
30627     try {
30628       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30629     } catch (std::out_of_range& e) {
30630       {
30631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30632       };
30633     } catch (std::exception& e) {
30634       {
30635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30636       };
30637     } catch (...) {
30638       {
30639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30640       };
30641     }
30642   }
30643 }
30644
30645
30646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30648   Dali::Degree *arg2 = 0 ;
30649   Dali::Vector3 *arg3 = 0 ;
30650
30651   arg1 = (Dali::Actor *)jarg1;
30652   arg2 = (Dali::Degree *)jarg2;
30653   if (!arg2) {
30654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30655     return ;
30656   }
30657   arg3 = (Dali::Vector3 *)jarg3;
30658   if (!arg3) {
30659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30660     return ;
30661   }
30662   {
30663     try {
30664       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30665     } catch (std::out_of_range& e) {
30666       {
30667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30668       };
30669     } catch (std::exception& e) {
30670       {
30671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30676       };
30677     }
30678   }
30679 }
30680
30681
30682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30684   Dali::Radian *arg2 = 0 ;
30685   Dali::Vector3 *arg3 = 0 ;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   arg2 = (Dali::Radian *)jarg2;
30689   if (!arg2) {
30690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30691     return ;
30692   }
30693   arg3 = (Dali::Vector3 *)jarg3;
30694   if (!arg3) {
30695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30696     return ;
30697   }
30698   {
30699     try {
30700       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30701     } catch (std::out_of_range& e) {
30702       {
30703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30704       };
30705     } catch (std::exception& e) {
30706       {
30707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30708       };
30709     } catch (...) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30712       };
30713     }
30714   }
30715 }
30716
30717
30718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30720   Dali::Quaternion *arg2 = 0 ;
30721
30722   arg1 = (Dali::Actor *)jarg1;
30723   arg2 = (Dali::Quaternion *)jarg2;
30724   if (!arg2) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30726     return ;
30727   }
30728   {
30729     try {
30730       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30738       };
30739     } catch (...) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30742       };
30743     }
30744   }
30745 }
30746
30747
30748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30749   void * jresult ;
30750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30751   Dali::Quaternion result;
30752
30753   arg1 = (Dali::Actor *)jarg1;
30754   {
30755     try {
30756       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30757     } catch (std::out_of_range& e) {
30758       {
30759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30760       };
30761     } catch (std::exception& e) {
30762       {
30763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30764       };
30765     } catch (...) {
30766       {
30767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30768       };
30769     }
30770   }
30771   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30772   return jresult;
30773 }
30774
30775
30776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30778   bool arg2 ;
30779
30780   arg1 = (Dali::Actor *)jarg1;
30781   arg2 = jarg2 ? true : false;
30782   {
30783     try {
30784       (arg1)->SetInheritOrientation(arg2);
30785     } catch (std::out_of_range& e) {
30786       {
30787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30788       };
30789     } catch (std::exception& e) {
30790       {
30791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30792       };
30793     } catch (...) {
30794       {
30795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30796       };
30797     }
30798   }
30799 }
30800
30801
30802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30803   unsigned int jresult ;
30804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30805   bool result;
30806
30807   arg1 = (Dali::Actor *)jarg1;
30808   {
30809     try {
30810       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30811     } catch (std::out_of_range& e) {
30812       {
30813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30814       };
30815     } catch (std::exception& e) {
30816       {
30817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30818       };
30819     } catch (...) {
30820       {
30821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30822       };
30823     }
30824   }
30825   jresult = result;
30826   return jresult;
30827 }
30828
30829
30830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30831   void * jresult ;
30832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30833   Dali::Quaternion result;
30834
30835   arg1 = (Dali::Actor *)jarg1;
30836   {
30837     try {
30838       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30839     } catch (std::out_of_range& e) {
30840       {
30841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30842       };
30843     } catch (std::exception& e) {
30844       {
30845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30850       };
30851     }
30852   }
30853   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30854   return jresult;
30855 }
30856
30857
30858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30860   float arg2 ;
30861
30862   arg1 = (Dali::Actor *)jarg1;
30863   arg2 = (float)jarg2;
30864   {
30865     try {
30866       (arg1)->SetScale(arg2);
30867     } catch (std::out_of_range& e) {
30868       {
30869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30870       };
30871     } catch (std::exception& e) {
30872       {
30873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30874       };
30875     } catch (...) {
30876       {
30877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30878       };
30879     }
30880   }
30881 }
30882
30883
30884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30886   float arg2 ;
30887   float arg3 ;
30888   float arg4 ;
30889
30890   arg1 = (Dali::Actor *)jarg1;
30891   arg2 = (float)jarg2;
30892   arg3 = (float)jarg3;
30893   arg4 = (float)jarg4;
30894   {
30895     try {
30896       (arg1)->SetScale(arg2,arg3,arg4);
30897     } catch (std::out_of_range& e) {
30898       {
30899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30900       };
30901     } catch (std::exception& e) {
30902       {
30903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30904       };
30905     } catch (...) {
30906       {
30907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30908       };
30909     }
30910   }
30911 }
30912
30913
30914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30915   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30916   Dali::Vector3 *arg2 = 0 ;
30917
30918   arg1 = (Dali::Actor *)jarg1;
30919   arg2 = (Dali::Vector3 *)jarg2;
30920   if (!arg2) {
30921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30922     return ;
30923   }
30924   {
30925     try {
30926       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30927     } catch (std::out_of_range& e) {
30928       {
30929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30930       };
30931     } catch (std::exception& e) {
30932       {
30933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30934       };
30935     } catch (...) {
30936       {
30937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30938       };
30939     }
30940   }
30941 }
30942
30943
30944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30945   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30946   Dali::Vector3 *arg2 = 0 ;
30947
30948   arg1 = (Dali::Actor *)jarg1;
30949   arg2 = (Dali::Vector3 *)jarg2;
30950   if (!arg2) {
30951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30952     return ;
30953   }
30954   {
30955     try {
30956       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30957     } catch (std::out_of_range& e) {
30958       {
30959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30960       };
30961     } catch (std::exception& e) {
30962       {
30963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30964       };
30965     } catch (...) {
30966       {
30967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30968       };
30969     }
30970   }
30971 }
30972
30973
30974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30975   void * jresult ;
30976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30977   Dali::Vector3 result;
30978
30979   arg1 = (Dali::Actor *)jarg1;
30980   {
30981     try {
30982       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30983     } catch (std::out_of_range& e) {
30984       {
30985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30986       };
30987     } catch (std::exception& e) {
30988       {
30989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30990       };
30991     } catch (...) {
30992       {
30993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30994       };
30995     }
30996   }
30997   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30998   return jresult;
30999 }
31000
31001
31002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31003   void * jresult ;
31004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31005   Dali::Vector3 result;
31006
31007   arg1 = (Dali::Actor *)jarg1;
31008   {
31009     try {
31010       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31011     } catch (std::out_of_range& e) {
31012       {
31013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31014       };
31015     } catch (std::exception& e) {
31016       {
31017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31018       };
31019     } catch (...) {
31020       {
31021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31022       };
31023     }
31024   }
31025   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31026   return jresult;
31027 }
31028
31029
31030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31031   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31032   bool arg2 ;
31033
31034   arg1 = (Dali::Actor *)jarg1;
31035   arg2 = jarg2 ? true : false;
31036   {
31037     try {
31038       (arg1)->SetInheritScale(arg2);
31039     } catch (std::out_of_range& e) {
31040       {
31041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31042       };
31043     } catch (std::exception& e) {
31044       {
31045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31046       };
31047     } catch (...) {
31048       {
31049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31050       };
31051     }
31052   }
31053 }
31054
31055
31056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31057   unsigned int jresult ;
31058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31059   bool result;
31060
31061   arg1 = (Dali::Actor *)jarg1;
31062   {
31063     try {
31064       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31065     } catch (std::out_of_range& e) {
31066       {
31067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31068       };
31069     } catch (std::exception& e) {
31070       {
31071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31072       };
31073     } catch (...) {
31074       {
31075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31076       };
31077     }
31078   }
31079   jresult = result;
31080   return jresult;
31081 }
31082
31083
31084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31085   void * jresult ;
31086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31087   Dali::Matrix result;
31088
31089   arg1 = (Dali::Actor *)jarg1;
31090   {
31091     try {
31092       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31093     } catch (std::out_of_range& e) {
31094       {
31095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31096       };
31097     } catch (std::exception& e) {
31098       {
31099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31100       };
31101     } catch (...) {
31102       {
31103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31104       };
31105     }
31106   }
31107   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31108   return jresult;
31109 }
31110
31111
31112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31113   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31114   bool arg2 ;
31115
31116   arg1 = (Dali::Actor *)jarg1;
31117   arg2 = jarg2 ? true : false;
31118   {
31119     try {
31120       (arg1)->SetVisible(arg2);
31121     } catch (std::out_of_range& e) {
31122       {
31123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31124       };
31125     } catch (std::exception& e) {
31126       {
31127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31128       };
31129     } catch (...) {
31130       {
31131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31132       };
31133     }
31134   }
31135 }
31136
31137
31138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31139   unsigned int jresult ;
31140   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31141   bool result;
31142
31143   arg1 = (Dali::Actor *)jarg1;
31144   {
31145     try {
31146       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31147     } catch (std::out_of_range& e) {
31148       {
31149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31150       };
31151     } catch (std::exception& e) {
31152       {
31153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31154       };
31155     } catch (...) {
31156       {
31157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31158       };
31159     }
31160   }
31161   jresult = result;
31162   return jresult;
31163 }
31164
31165
31166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31167   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31168   float arg2 ;
31169
31170   arg1 = (Dali::Actor *)jarg1;
31171   arg2 = (float)jarg2;
31172   {
31173     try {
31174       (arg1)->SetOpacity(arg2);
31175     } catch (std::out_of_range& e) {
31176       {
31177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31178       };
31179     } catch (std::exception& e) {
31180       {
31181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31182       };
31183     } catch (...) {
31184       {
31185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31186       };
31187     }
31188   }
31189 }
31190
31191
31192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31193   float jresult ;
31194   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31195   float result;
31196
31197   arg1 = (Dali::Actor *)jarg1;
31198   {
31199     try {
31200       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31201     } catch (std::out_of_range& e) {
31202       {
31203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31204       };
31205     } catch (std::exception& e) {
31206       {
31207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31208       };
31209     } catch (...) {
31210       {
31211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31212       };
31213     }
31214   }
31215   jresult = result;
31216   return jresult;
31217 }
31218
31219
31220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31222   Dali::Vector4 *arg2 = 0 ;
31223
31224   arg1 = (Dali::Actor *)jarg1;
31225   arg2 = (Dali::Vector4 *)jarg2;
31226   if (!arg2) {
31227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31228     return ;
31229   }
31230   {
31231     try {
31232       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31233     } catch (std::out_of_range& e) {
31234       {
31235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31236       };
31237     } catch (std::exception& e) {
31238       {
31239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31240       };
31241     } catch (...) {
31242       {
31243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31244       };
31245     }
31246   }
31247 }
31248
31249
31250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31251   void * jresult ;
31252   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31253   Dali::Vector4 result;
31254
31255   arg1 = (Dali::Actor *)jarg1;
31256   {
31257     try {
31258       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31259     } catch (std::out_of_range& e) {
31260       {
31261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31262       };
31263     } catch (std::exception& e) {
31264       {
31265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31266       };
31267     } catch (...) {
31268       {
31269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31270       };
31271     }
31272   }
31273   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31274   return jresult;
31275 }
31276
31277
31278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31280   Dali::ColorMode arg2 ;
31281
31282   arg1 = (Dali::Actor *)jarg1;
31283   arg2 = (Dali::ColorMode)jarg2;
31284   {
31285     try {
31286       (arg1)->SetColorMode(arg2);
31287     } catch (std::out_of_range& e) {
31288       {
31289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31290       };
31291     } catch (std::exception& e) {
31292       {
31293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31294       };
31295     } catch (...) {
31296       {
31297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31298       };
31299     }
31300   }
31301 }
31302
31303
31304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31305   int jresult ;
31306   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31307   Dali::ColorMode result;
31308
31309   arg1 = (Dali::Actor *)jarg1;
31310   {
31311     try {
31312       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31313     } catch (std::out_of_range& e) {
31314       {
31315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31316       };
31317     } catch (std::exception& e) {
31318       {
31319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31320       };
31321     } catch (...) {
31322       {
31323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31324       };
31325     }
31326   }
31327   jresult = (int)result;
31328   return jresult;
31329 }
31330
31331
31332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31333   void * jresult ;
31334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31335   Dali::Vector4 result;
31336
31337   arg1 = (Dali::Actor *)jarg1;
31338   {
31339     try {
31340       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31341     } catch (std::out_of_range& e) {
31342       {
31343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31344       };
31345     } catch (std::exception& e) {
31346       {
31347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31348       };
31349     } catch (...) {
31350       {
31351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31352       };
31353     }
31354   }
31355   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31356   return jresult;
31357 }
31358
31359
31360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31362   Dali::DrawMode::Type arg2 ;
31363
31364   arg1 = (Dali::Actor *)jarg1;
31365   arg2 = (Dali::DrawMode::Type)jarg2;
31366   {
31367     try {
31368       (arg1)->SetDrawMode(arg2);
31369     } catch (std::out_of_range& e) {
31370       {
31371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31372       };
31373     } catch (std::exception& e) {
31374       {
31375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31376       };
31377     } catch (...) {
31378       {
31379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31380       };
31381     }
31382   }
31383 }
31384
31385
31386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31387   int jresult ;
31388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31389   Dali::DrawMode::Type result;
31390
31391   arg1 = (Dali::Actor *)jarg1;
31392   {
31393     try {
31394       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31395     } catch (std::out_of_range& e) {
31396       {
31397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31398       };
31399     } catch (std::exception& e) {
31400       {
31401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31402       };
31403     } catch (...) {
31404       {
31405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31406       };
31407     }
31408   }
31409   jresult = (int)result;
31410   return jresult;
31411 }
31412
31413
31414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31416   bool arg2 ;
31417
31418   arg1 = (Dali::Actor *)jarg1;
31419   arg2 = jarg2 ? true : false;
31420   {
31421     try {
31422       (arg1)->SetSensitive(arg2);
31423     } catch (std::out_of_range& e) {
31424       {
31425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31426       };
31427     } catch (std::exception& e) {
31428       {
31429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31430       };
31431     } catch (...) {
31432       {
31433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31434       };
31435     }
31436   }
31437 }
31438
31439
31440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31441   unsigned int jresult ;
31442   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31443   bool result;
31444
31445   arg1 = (Dali::Actor *)jarg1;
31446   {
31447     try {
31448       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31449     } catch (std::out_of_range& e) {
31450       {
31451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31452       };
31453     } catch (std::exception& e) {
31454       {
31455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31456       };
31457     } catch (...) {
31458       {
31459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31460       };
31461     }
31462   }
31463   jresult = result;
31464   return jresult;
31465 }
31466
31467
31468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31469   unsigned int jresult ;
31470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31471   float *arg2 = 0 ;
31472   float *arg3 = 0 ;
31473   float arg4 ;
31474   float arg5 ;
31475   bool result;
31476
31477   arg1 = (Dali::Actor *)jarg1;
31478   arg2 = (float *)jarg2;
31479   arg3 = (float *)jarg3;
31480   arg4 = (float)jarg4;
31481   arg5 = (float)jarg5;
31482   {
31483     try {
31484       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31485     } catch (std::out_of_range& e) {
31486       {
31487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31488       };
31489     } catch (std::exception& e) {
31490       {
31491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31492       };
31493     } catch (...) {
31494       {
31495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31496       };
31497     }
31498   }
31499   jresult = result;
31500   return jresult;
31501 }
31502
31503
31504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31505   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31506   bool arg2 ;
31507
31508   arg1 = (Dali::Actor *)jarg1;
31509   arg2 = jarg2 ? true : false;
31510   {
31511     try {
31512       (arg1)->SetLeaveRequired(arg2);
31513     } catch (std::out_of_range& e) {
31514       {
31515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31516       };
31517     } catch (std::exception& e) {
31518       {
31519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31520       };
31521     } catch (...) {
31522       {
31523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31524       };
31525     }
31526   }
31527 }
31528
31529
31530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31531   unsigned int jresult ;
31532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31533   bool result;
31534
31535   arg1 = (Dali::Actor *)jarg1;
31536   {
31537     try {
31538       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31539     } catch (std::out_of_range& e) {
31540       {
31541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31542       };
31543     } catch (std::exception& e) {
31544       {
31545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31546       };
31547     } catch (...) {
31548       {
31549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31550       };
31551     }
31552   }
31553   jresult = result;
31554   return jresult;
31555 }
31556
31557
31558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31560   bool arg2 ;
31561
31562   arg1 = (Dali::Actor *)jarg1;
31563   arg2 = jarg2 ? true : false;
31564   {
31565     try {
31566       (arg1)->SetKeyboardFocusable(arg2);
31567     } catch (std::out_of_range& e) {
31568       {
31569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31570       };
31571     } catch (std::exception& e) {
31572       {
31573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31574       };
31575     } catch (...) {
31576       {
31577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31578       };
31579     }
31580   }
31581 }
31582
31583
31584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31585   unsigned int jresult ;
31586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31587   bool result;
31588
31589   arg1 = (Dali::Actor *)jarg1;
31590   {
31591     try {
31592       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31593     } catch (std::out_of_range& e) {
31594       {
31595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31596       };
31597     } catch (std::exception& e) {
31598       {
31599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31600       };
31601     } catch (...) {
31602       {
31603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31604       };
31605     }
31606   }
31607   jresult = result;
31608   return jresult;
31609 }
31610
31611
31612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31614   Dali::ResizePolicy::Type arg2 ;
31615   Dali::Dimension::Type arg3 ;
31616
31617   arg1 = (Dali::Actor *)jarg1;
31618   arg2 = (Dali::ResizePolicy::Type)jarg2;
31619   arg3 = (Dali::Dimension::Type)jarg3;
31620   {
31621     try {
31622       (arg1)->SetResizePolicy(arg2,arg3);
31623     } catch (std::out_of_range& e) {
31624       {
31625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31626       };
31627     } catch (std::exception& e) {
31628       {
31629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31630       };
31631     } catch (...) {
31632       {
31633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31634       };
31635     }
31636   }
31637 }
31638
31639
31640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31641   int jresult ;
31642   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31643   Dali::Dimension::Type arg2 ;
31644   Dali::ResizePolicy::Type result;
31645
31646   arg1 = (Dali::Actor *)jarg1;
31647   arg2 = (Dali::Dimension::Type)jarg2;
31648   {
31649     try {
31650       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31651     } catch (std::out_of_range& e) {
31652       {
31653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31654       };
31655     } catch (std::exception& e) {
31656       {
31657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31658       };
31659     } catch (...) {
31660       {
31661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31662       };
31663     }
31664   }
31665   jresult = (int)result;
31666   return jresult;
31667 }
31668
31669
31670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31672   Dali::SizeScalePolicy::Type arg2 ;
31673
31674   arg1 = (Dali::Actor *)jarg1;
31675   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31676   {
31677     try {
31678       (arg1)->SetSizeScalePolicy(arg2);
31679     } catch (std::out_of_range& e) {
31680       {
31681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31682       };
31683     } catch (std::exception& e) {
31684       {
31685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31690       };
31691     }
31692   }
31693 }
31694
31695
31696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31697   int jresult ;
31698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31699   Dali::SizeScalePolicy::Type result;
31700
31701   arg1 = (Dali::Actor *)jarg1;
31702   {
31703     try {
31704       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31705     } catch (std::out_of_range& e) {
31706       {
31707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (std::exception& e) {
31710       {
31711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (...) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31716       };
31717     }
31718   }
31719   jresult = (int)result;
31720   return jresult;
31721 }
31722
31723
31724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31726   Dali::Vector3 *arg2 = 0 ;
31727
31728   arg1 = (Dali::Actor *)jarg1;
31729   arg2 = (Dali::Vector3 *)jarg2;
31730   if (!arg2) {
31731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31732     return ;
31733   }
31734   {
31735     try {
31736       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31737     } catch (std::out_of_range& e) {
31738       {
31739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31740       };
31741     } catch (std::exception& e) {
31742       {
31743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (...) {
31746       {
31747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31748       };
31749     }
31750   }
31751 }
31752
31753
31754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31755   void * jresult ;
31756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31757   Dali::Vector3 result;
31758
31759   arg1 = (Dali::Actor *)jarg1;
31760   {
31761     try {
31762       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31763     } catch (std::out_of_range& e) {
31764       {
31765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31766       };
31767     } catch (std::exception& e) {
31768       {
31769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (...) {
31772       {
31773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31774       };
31775     }
31776   }
31777   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31778   return jresult;
31779 }
31780
31781
31782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31783   float jresult ;
31784   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31785   float arg2 ;
31786   float result;
31787
31788   arg1 = (Dali::Actor *)jarg1;
31789   arg2 = (float)jarg2;
31790   {
31791     try {
31792       result = (float)(arg1)->GetHeightForWidth(arg2);
31793     } catch (std::out_of_range& e) {
31794       {
31795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31796       };
31797     } catch (std::exception& e) {
31798       {
31799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31800       };
31801     } catch (...) {
31802       {
31803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31804       };
31805     }
31806   }
31807   jresult = result;
31808   return jresult;
31809 }
31810
31811
31812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31813   float jresult ;
31814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31815   float arg2 ;
31816   float result;
31817
31818   arg1 = (Dali::Actor *)jarg1;
31819   arg2 = (float)jarg2;
31820   {
31821     try {
31822       result = (float)(arg1)->GetWidthForHeight(arg2);
31823     } catch (std::out_of_range& e) {
31824       {
31825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31826       };
31827     } catch (std::exception& e) {
31828       {
31829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (...) {
31832       {
31833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31834       };
31835     }
31836   }
31837   jresult = result;
31838   return jresult;
31839 }
31840
31841
31842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31843   float jresult ;
31844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31845   Dali::Dimension::Type arg2 ;
31846   float result;
31847
31848   arg1 = (Dali::Actor *)jarg1;
31849   arg2 = (Dali::Dimension::Type)jarg2;
31850   {
31851     try {
31852       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31853     } catch (std::out_of_range& e) {
31854       {
31855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31856       };
31857     } catch (std::exception& e) {
31858       {
31859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31860       };
31861     } catch (...) {
31862       {
31863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31864       };
31865     }
31866   }
31867   jresult = result;
31868   return jresult;
31869 }
31870
31871
31872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31874   Dali::Padding *arg2 = 0 ;
31875
31876   arg1 = (Dali::Actor *)jarg1;
31877   arg2 = (Dali::Padding *)jarg2;
31878   if (!arg2) {
31879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31880     return ;
31881   }
31882   {
31883     try {
31884       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31885     } catch (std::out_of_range& e) {
31886       {
31887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31888       };
31889     } catch (std::exception& e) {
31890       {
31891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31892       };
31893     } catch (...) {
31894       {
31895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31896       };
31897     }
31898   }
31899 }
31900
31901
31902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31904   Dali::Padding *arg2 = 0 ;
31905
31906   arg1 = (Dali::Actor *)jarg1;
31907   arg2 = (Dali::Padding *)jarg2;
31908   if (!arg2) {
31909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31910     return ;
31911   }
31912   {
31913     try {
31914       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31915     } catch (std::out_of_range& e) {
31916       {
31917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31918       };
31919     } catch (std::exception& e) {
31920       {
31921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31922       };
31923     } catch (...) {
31924       {
31925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31926       };
31927     }
31928   }
31929 }
31930
31931
31932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31934   Dali::Vector2 *arg2 = 0 ;
31935
31936   arg1 = (Dali::Actor *)jarg1;
31937   arg2 = (Dali::Vector2 *)jarg2;
31938   if (!arg2) {
31939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31940     return ;
31941   }
31942   {
31943     try {
31944       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31945     } catch (std::out_of_range& e) {
31946       {
31947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31948       };
31949     } catch (std::exception& e) {
31950       {
31951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31952       };
31953     } catch (...) {
31954       {
31955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31956       };
31957     }
31958   }
31959 }
31960
31961
31962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31963   void * jresult ;
31964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31965   Dali::Vector2 result;
31966
31967   arg1 = (Dali::Actor *)jarg1;
31968   {
31969     try {
31970       result = (arg1)->GetMinimumSize();
31971     } catch (std::out_of_range& e) {
31972       {
31973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31974       };
31975     } catch (std::exception& e) {
31976       {
31977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31978       };
31979     } catch (...) {
31980       {
31981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31982       };
31983     }
31984   }
31985   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31986   return jresult;
31987 }
31988
31989
31990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31991   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31992   Dali::Vector2 *arg2 = 0 ;
31993
31994   arg1 = (Dali::Actor *)jarg1;
31995   arg2 = (Dali::Vector2 *)jarg2;
31996   if (!arg2) {
31997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31998     return ;
31999   }
32000   {
32001     try {
32002       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32003     } catch (std::out_of_range& e) {
32004       {
32005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32006       };
32007     } catch (std::exception& e) {
32008       {
32009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32010       };
32011     } catch (...) {
32012       {
32013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32014       };
32015     }
32016   }
32017 }
32018
32019
32020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32021   void * jresult ;
32022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32023   Dali::Vector2 result;
32024
32025   arg1 = (Dali::Actor *)jarg1;
32026   {
32027     try {
32028       result = (arg1)->GetMaximumSize();
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (...) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32040       };
32041     }
32042   }
32043   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32044   return jresult;
32045 }
32046
32047
32048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32049   int jresult ;
32050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32051   int result;
32052
32053   arg1 = (Dali::Actor *)jarg1;
32054   {
32055     try {
32056       result = (int)(arg1)->GetHierarchyDepth();
32057     } catch (std::out_of_range& e) {
32058       {
32059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32060       };
32061     } catch (std::exception& e) {
32062       {
32063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32064       };
32065     } catch (...) {
32066       {
32067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32068       };
32069     }
32070   }
32071   jresult = result;
32072   return jresult;
32073 }
32074
32075
32076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32077   unsigned int jresult ;
32078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32079   Dali::Renderer *arg2 = 0 ;
32080   unsigned int result;
32081
32082   arg1 = (Dali::Actor *)jarg1;
32083   arg2 = (Dali::Renderer *)jarg2;
32084   if (!arg2) {
32085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32086     return 0;
32087   }
32088   {
32089     try {
32090       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32091     } catch (std::out_of_range& e) {
32092       {
32093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32094       };
32095     } catch (std::exception& e) {
32096       {
32097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32098       };
32099     } catch (...) {
32100       {
32101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32102       };
32103     }
32104   }
32105   jresult = result;
32106   return jresult;
32107 }
32108
32109
32110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32111   unsigned int jresult ;
32112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32113   unsigned int result;
32114
32115   arg1 = (Dali::Actor *)jarg1;
32116   {
32117     try {
32118       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32119     } catch (std::out_of_range& e) {
32120       {
32121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32122       };
32123     } catch (std::exception& e) {
32124       {
32125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32126       };
32127     } catch (...) {
32128       {
32129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32130       };
32131     }
32132   }
32133   jresult = result;
32134   return jresult;
32135 }
32136
32137
32138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32139   void * jresult ;
32140   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32141   unsigned int arg2 ;
32142   Dali::Renderer result;
32143
32144   arg1 = (Dali::Actor *)jarg1;
32145   arg2 = (unsigned int)jarg2;
32146   {
32147     try {
32148       result = (arg1)->GetRendererAt(arg2);
32149     } catch (std::out_of_range& e) {
32150       {
32151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32152       };
32153     } catch (std::exception& e) {
32154       {
32155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32156       };
32157     } catch (...) {
32158       {
32159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32160       };
32161     }
32162   }
32163   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32164   return jresult;
32165 }
32166
32167
32168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32170   Dali::Renderer *arg2 = 0 ;
32171
32172   arg1 = (Dali::Actor *)jarg1;
32173   arg2 = (Dali::Renderer *)jarg2;
32174   if (!arg2) {
32175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32176     return ;
32177   }
32178   {
32179     try {
32180       (arg1)->RemoveRenderer(*arg2);
32181     } catch (std::out_of_range& e) {
32182       {
32183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32184       };
32185     } catch (std::exception& e) {
32186       {
32187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32188       };
32189     } catch (...) {
32190       {
32191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32192       };
32193     }
32194   }
32195 }
32196
32197
32198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32200   unsigned int arg2 ;
32201
32202   arg1 = (Dali::Actor *)jarg1;
32203   arg2 = (unsigned int)jarg2;
32204   {
32205     try {
32206       (arg1)->RemoveRenderer(arg2);
32207     } catch (std::out_of_range& e) {
32208       {
32209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32210       };
32211     } catch (std::exception& e) {
32212       {
32213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32214       };
32215     } catch (...) {
32216       {
32217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32218       };
32219     }
32220   }
32221 }
32222
32223
32224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32225   void * jresult ;
32226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32227   Dali::Actor::TouchSignalType *result = 0 ;
32228
32229   arg1 = (Dali::Actor *)jarg1;
32230   {
32231     try {
32232       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32233     } catch (std::out_of_range& e) {
32234       {
32235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32236       };
32237     } catch (std::exception& e) {
32238       {
32239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32240       };
32241     } catch (...) {
32242       {
32243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32244       };
32245     }
32246   }
32247   jresult = (void *)result;
32248   return jresult;
32249 }
32250
32251
32252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32253   void * jresult ;
32254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32255   Dali::Actor::TouchDataSignalType *result = 0 ;
32256
32257   arg1 = (Dali::Actor *)jarg1;
32258   {
32259     try {
32260       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32261     } catch (std::out_of_range& e) {
32262       {
32263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32264       };
32265     } catch (std::exception& e) {
32266       {
32267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32268       };
32269     } catch (...) {
32270       {
32271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32272       };
32273     }
32274   }
32275   jresult = (void *)result;
32276   return jresult;
32277 }
32278
32279
32280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32281   void * jresult ;
32282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32283   Dali::Actor::HoverSignalType *result = 0 ;
32284
32285   arg1 = (Dali::Actor *)jarg1;
32286   {
32287     try {
32288       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32289     } catch (std::out_of_range& e) {
32290       {
32291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32292       };
32293     } catch (std::exception& e) {
32294       {
32295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32296       };
32297     } catch (...) {
32298       {
32299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32300       };
32301     }
32302   }
32303   jresult = (void *)result;
32304   return jresult;
32305 }
32306
32307
32308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32309   void * jresult ;
32310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32311   Dali::Actor::WheelEventSignalType *result = 0 ;
32312
32313   arg1 = (Dali::Actor *)jarg1;
32314   {
32315     try {
32316       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32317     } catch (std::out_of_range& e) {
32318       {
32319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32320       };
32321     } catch (std::exception& e) {
32322       {
32323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32324       };
32325     } catch (...) {
32326       {
32327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32328       };
32329     }
32330   }
32331   jresult = (void *)result;
32332   return jresult;
32333 }
32334
32335
32336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32337   void * jresult ;
32338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32339   Dali::Actor::OnStageSignalType *result = 0 ;
32340
32341   arg1 = (Dali::Actor *)jarg1;
32342   {
32343     try {
32344       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32345     } catch (std::out_of_range& e) {
32346       {
32347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32348       };
32349     } catch (std::exception& e) {
32350       {
32351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32352       };
32353     } catch (...) {
32354       {
32355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32356       };
32357     }
32358   }
32359   jresult = (void *)result;
32360   return jresult;
32361 }
32362
32363
32364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32365   void * jresult ;
32366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32367   Dali::Actor::OffStageSignalType *result = 0 ;
32368
32369   arg1 = (Dali::Actor *)jarg1;
32370   {
32371     try {
32372       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32373     } catch (std::out_of_range& e) {
32374       {
32375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32376       };
32377     } catch (std::exception& e) {
32378       {
32379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32380       };
32381     } catch (...) {
32382       {
32383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32384       };
32385     }
32386   }
32387   jresult = (void *)result;
32388   return jresult;
32389 }
32390
32391
32392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32393   void * jresult ;
32394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32395   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32396
32397   arg1 = (Dali::Actor *)jarg1;
32398   {
32399     try {
32400       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32401     } catch (std::out_of_range& e) {
32402       {
32403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32404       };
32405     } catch (std::exception& e) {
32406       {
32407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32408       };
32409     } catch (...) {
32410       {
32411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32412       };
32413     }
32414   }
32415   jresult = (void *)result;
32416   return jresult;
32417 }
32418
32419
32420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32421   Dali::Actor *arg1 = 0 ;
32422
32423   arg1 = (Dali::Actor *)jarg1;
32424   if (!arg1) {
32425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32426     return ;
32427   }
32428   {
32429     try {
32430       Dali::UnparentAndReset(*arg1);
32431     } catch (std::out_of_range& e) {
32432       {
32433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32434       };
32435     } catch (std::exception& e) {
32436       {
32437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32438       };
32439     } catch (...) {
32440       {
32441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32442       };
32443     }
32444   }
32445 }
32446
32447
32448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32449   int jresult ;
32450   int result;
32451
32452   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32453   jresult = (int)result;
32454   return jresult;
32455 }
32456
32457
32458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32459   int jresult ;
32460   int result;
32461
32462   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32463   jresult = (int)result;
32464   return jresult;
32465 }
32466
32467
32468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32469   int jresult ;
32470   int result;
32471
32472   result = (int)Dali::Layer::Property::BEHAVIOR;
32473   jresult = (int)result;
32474   return jresult;
32475 }
32476
32477
32478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32479   void * jresult ;
32480   Dali::Layer::Property *result = 0 ;
32481
32482   {
32483     try {
32484       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32485     } catch (std::out_of_range& e) {
32486       {
32487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32488       };
32489     } catch (std::exception& e) {
32490       {
32491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32492       };
32493     } catch (...) {
32494       {
32495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32496       };
32497     }
32498   }
32499   jresult = (void *)result;
32500   return jresult;
32501 }
32502
32503
32504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32505   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32506
32507   arg1 = (Dali::Layer::Property *)jarg1;
32508   {
32509     try {
32510       delete arg1;
32511     } catch (std::out_of_range& e) {
32512       {
32513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32514       };
32515     } catch (std::exception& e) {
32516       {
32517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32518       };
32519     } catch (...) {
32520       {
32521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32522       };
32523     }
32524   }
32525 }
32526
32527
32528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32529   void * jresult ;
32530   Dali::Layer *result = 0 ;
32531
32532   {
32533     try {
32534       result = (Dali::Layer *)new Dali::Layer();
32535     } catch (std::out_of_range& e) {
32536       {
32537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32538       };
32539     } catch (std::exception& e) {
32540       {
32541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (...) {
32544       {
32545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32546       };
32547     }
32548   }
32549   jresult = (void *)result;
32550   return jresult;
32551 }
32552
32553
32554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32555   void * jresult ;
32556   Dali::Layer result;
32557
32558   {
32559     try {
32560       result = Dali::Layer::New();
32561     } catch (std::out_of_range& e) {
32562       {
32563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32564       };
32565     } catch (std::exception& e) {
32566       {
32567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32568       };
32569     } catch (...) {
32570       {
32571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32572       };
32573     }
32574   }
32575   jresult = new Dali::Layer((const Dali::Layer &)result);
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32581   void * jresult ;
32582   Dali::BaseHandle arg1 ;
32583   Dali::BaseHandle *argp1 ;
32584   Dali::Layer result;
32585
32586   argp1 = (Dali::BaseHandle *)jarg1;
32587   if (!argp1) {
32588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32589     return 0;
32590   }
32591   arg1 = *argp1;
32592   {
32593     try {
32594       result = Dali::Layer::DownCast(arg1);
32595     } catch (std::out_of_range& e) {
32596       {
32597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32598       };
32599     } catch (std::exception& e) {
32600       {
32601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32602       };
32603     } catch (...) {
32604       {
32605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32606       };
32607     }
32608   }
32609   jresult = new Dali::Layer((const Dali::Layer &)result);
32610   return jresult;
32611 }
32612
32613
32614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32615   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32616
32617   arg1 = (Dali::Layer *)jarg1;
32618   {
32619     try {
32620       delete arg1;
32621     } catch (std::out_of_range& e) {
32622       {
32623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32624       };
32625     } catch (std::exception& e) {
32626       {
32627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32628       };
32629     } catch (...) {
32630       {
32631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32632       };
32633     }
32634   }
32635 }
32636
32637
32638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32639   void * jresult ;
32640   Dali::Layer *arg1 = 0 ;
32641   Dali::Layer *result = 0 ;
32642
32643   arg1 = (Dali::Layer *)jarg1;
32644   if (!arg1) {
32645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32646     return 0;
32647   }
32648   {
32649     try {
32650       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32651     } catch (std::out_of_range& e) {
32652       {
32653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32654       };
32655     } catch (std::exception& e) {
32656       {
32657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32662       };
32663     }
32664   }
32665   jresult = (void *)result;
32666   return jresult;
32667 }
32668
32669
32670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32671   void * jresult ;
32672   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32673   Dali::Layer *arg2 = 0 ;
32674   Dali::Layer *result = 0 ;
32675
32676   arg1 = (Dali::Layer *)jarg1;
32677   arg2 = (Dali::Layer *)jarg2;
32678   if (!arg2) {
32679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32680     return 0;
32681   }
32682   {
32683     try {
32684       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32685     } catch (std::out_of_range& e) {
32686       {
32687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32688       };
32689     } catch (std::exception& e) {
32690       {
32691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32692       };
32693     } catch (...) {
32694       {
32695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32696       };
32697     }
32698   }
32699   jresult = (void *)result;
32700   return jresult;
32701 }
32702
32703
32704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32705   unsigned int jresult ;
32706   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32707   unsigned int result;
32708
32709   arg1 = (Dali::Layer *)jarg1;
32710   {
32711     try {
32712       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32713     } catch (std::out_of_range& e) {
32714       {
32715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32716       };
32717     } catch (std::exception& e) {
32718       {
32719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32720       };
32721     } catch (...) {
32722       {
32723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32724       };
32725     }
32726   }
32727   jresult = result;
32728   return jresult;
32729 }
32730
32731
32732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32733   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32734
32735   arg1 = (Dali::Layer *)jarg1;
32736   {
32737     try {
32738       (arg1)->Raise();
32739     } catch (std::out_of_range& e) {
32740       {
32741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32742       };
32743     } catch (std::exception& e) {
32744       {
32745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32746       };
32747     } catch (...) {
32748       {
32749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32750       };
32751     }
32752   }
32753 }
32754
32755
32756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32757   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32758
32759   arg1 = (Dali::Layer *)jarg1;
32760   {
32761     try {
32762       (arg1)->Lower();
32763     } catch (std::out_of_range& e) {
32764       {
32765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32766       };
32767     } catch (std::exception& e) {
32768       {
32769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32770       };
32771     } catch (...) {
32772       {
32773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32774       };
32775     }
32776   }
32777 }
32778
32779
32780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32781   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32782   Dali::Layer arg2 ;
32783   Dali::Layer *argp2 ;
32784
32785   arg1 = (Dali::Layer *)jarg1;
32786   argp2 = (Dali::Layer *)jarg2;
32787   if (!argp2) {
32788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32789     return ;
32790   }
32791   arg2 = *argp2;
32792   {
32793     try {
32794       (arg1)->RaiseAbove(arg2);
32795     } catch (std::out_of_range& e) {
32796       {
32797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32798       };
32799     } catch (std::exception& e) {
32800       {
32801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32802       };
32803     } catch (...) {
32804       {
32805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32806       };
32807     }
32808   }
32809 }
32810
32811
32812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32813   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32814   Dali::Layer arg2 ;
32815   Dali::Layer *argp2 ;
32816
32817   arg1 = (Dali::Layer *)jarg1;
32818   argp2 = (Dali::Layer *)jarg2;
32819   if (!argp2) {
32820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32821     return ;
32822   }
32823   arg2 = *argp2;
32824   {
32825     try {
32826       (arg1)->LowerBelow(arg2);
32827     } catch (std::out_of_range& e) {
32828       {
32829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32830       };
32831     } catch (std::exception& e) {
32832       {
32833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32834       };
32835     } catch (...) {
32836       {
32837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32838       };
32839     }
32840   }
32841 }
32842
32843
32844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32845   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32846
32847   arg1 = (Dali::Layer *)jarg1;
32848   {
32849     try {
32850       (arg1)->RaiseToTop();
32851     } catch (std::out_of_range& e) {
32852       {
32853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32854       };
32855     } catch (std::exception& e) {
32856       {
32857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32858       };
32859     } catch (...) {
32860       {
32861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32862       };
32863     }
32864   }
32865 }
32866
32867
32868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32869   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32870
32871   arg1 = (Dali::Layer *)jarg1;
32872   {
32873     try {
32874       (arg1)->LowerToBottom();
32875     } catch (std::out_of_range& e) {
32876       {
32877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32878       };
32879     } catch (std::exception& e) {
32880       {
32881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32882       };
32883     } catch (...) {
32884       {
32885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32886       };
32887     }
32888   }
32889 }
32890
32891
32892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32893   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32894   Dali::Layer arg2 ;
32895   Dali::Layer *argp2 ;
32896
32897   arg1 = (Dali::Layer *)jarg1;
32898   argp2 = (Dali::Layer *)jarg2;
32899   if (!argp2) {
32900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32901     return ;
32902   }
32903   arg2 = *argp2;
32904   {
32905     try {
32906       (arg1)->MoveAbove(arg2);
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32914       };
32915     } catch (...) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32918       };
32919     }
32920   }
32921 }
32922
32923
32924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32925   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32926   Dali::Layer arg2 ;
32927   Dali::Layer *argp2 ;
32928
32929   arg1 = (Dali::Layer *)jarg1;
32930   argp2 = (Dali::Layer *)jarg2;
32931   if (!argp2) {
32932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32933     return ;
32934   }
32935   arg2 = *argp2;
32936   {
32937     try {
32938       (arg1)->MoveBelow(arg2);
32939     } catch (std::out_of_range& e) {
32940       {
32941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32942       };
32943     } catch (std::exception& e) {
32944       {
32945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32946       };
32947     } catch (...) {
32948       {
32949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32950       };
32951     }
32952   }
32953 }
32954
32955
32956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32957   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32958   Dali::Layer::Behavior arg2 ;
32959
32960   arg1 = (Dali::Layer *)jarg1;
32961   arg2 = (Dali::Layer::Behavior)jarg2;
32962   {
32963     try {
32964       (arg1)->SetBehavior(arg2);
32965     } catch (std::out_of_range& e) {
32966       {
32967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32968       };
32969     } catch (std::exception& e) {
32970       {
32971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32972       };
32973     } catch (...) {
32974       {
32975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32976       };
32977     }
32978   }
32979 }
32980
32981
32982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32983   int jresult ;
32984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32985   Dali::Layer::Behavior result;
32986
32987   arg1 = (Dali::Layer *)jarg1;
32988   {
32989     try {
32990       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32991     } catch (std::out_of_range& e) {
32992       {
32993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32994       };
32995     } catch (std::exception& e) {
32996       {
32997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32998       };
32999     } catch (...) {
33000       {
33001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33002       };
33003     }
33004   }
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33011   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33012   bool arg2 ;
33013
33014   arg1 = (Dali::Layer *)jarg1;
33015   arg2 = jarg2 ? true : false;
33016   {
33017     try {
33018       (arg1)->SetClipping(arg2);
33019     } catch (std::out_of_range& e) {
33020       {
33021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33022       };
33023     } catch (std::exception& e) {
33024       {
33025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33026       };
33027     } catch (...) {
33028       {
33029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33030       };
33031     }
33032   }
33033 }
33034
33035
33036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33037   unsigned int jresult ;
33038   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33039   bool result;
33040
33041   arg1 = (Dali::Layer *)jarg1;
33042   {
33043     try {
33044       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33045     } catch (std::out_of_range& e) {
33046       {
33047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33048       };
33049     } catch (std::exception& e) {
33050       {
33051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33052       };
33053     } catch (...) {
33054       {
33055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33056       };
33057     }
33058   }
33059   jresult = result;
33060   return jresult;
33061 }
33062
33063
33064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33065   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33066   int arg2 ;
33067   int arg3 ;
33068   int arg4 ;
33069   int arg5 ;
33070
33071   arg1 = (Dali::Layer *)jarg1;
33072   arg2 = (int)jarg2;
33073   arg3 = (int)jarg3;
33074   arg4 = (int)jarg4;
33075   arg5 = (int)jarg5;
33076   {
33077     try {
33078       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33079     } catch (std::out_of_range& e) {
33080       {
33081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33082       };
33083     } catch (std::exception& e) {
33084       {
33085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33086       };
33087     } catch (...) {
33088       {
33089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33090       };
33091     }
33092   }
33093 }
33094
33095
33096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33097   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33098   Dali::ClippingBox arg2 ;
33099   Dali::ClippingBox *argp2 ;
33100
33101   arg1 = (Dali::Layer *)jarg1;
33102   argp2 = (Dali::ClippingBox *)jarg2;
33103   if (!argp2) {
33104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33105     return ;
33106   }
33107   arg2 = *argp2;
33108   {
33109     try {
33110       (arg1)->SetClippingBox(arg2);
33111     } catch (std::out_of_range& e) {
33112       {
33113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33114       };
33115     } catch (std::exception& e) {
33116       {
33117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33118       };
33119     } catch (...) {
33120       {
33121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33122       };
33123     }
33124   }
33125 }
33126
33127
33128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33129   void * jresult ;
33130   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33131   Dali::ClippingBox result;
33132
33133   arg1 = (Dali::Layer *)jarg1;
33134   {
33135     try {
33136       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33137     } catch (std::out_of_range& e) {
33138       {
33139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33140       };
33141     } catch (std::exception& e) {
33142       {
33143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33144       };
33145     } catch (...) {
33146       {
33147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33148       };
33149     }
33150   }
33151   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33152   return jresult;
33153 }
33154
33155
33156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33157   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33158   bool arg2 ;
33159
33160   arg1 = (Dali::Layer *)jarg1;
33161   arg2 = jarg2 ? true : false;
33162   {
33163     try {
33164       (arg1)->SetDepthTestDisabled(arg2);
33165     } catch (std::out_of_range& e) {
33166       {
33167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33168       };
33169     } catch (std::exception& e) {
33170       {
33171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33172       };
33173     } catch (...) {
33174       {
33175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33176       };
33177     }
33178   }
33179 }
33180
33181
33182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33183   unsigned int jresult ;
33184   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33185   bool result;
33186
33187   arg1 = (Dali::Layer *)jarg1;
33188   {
33189     try {
33190       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33191     } catch (std::out_of_range& e) {
33192       {
33193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33194       };
33195     } catch (std::exception& e) {
33196       {
33197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33198       };
33199     } catch (...) {
33200       {
33201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33202       };
33203     }
33204   }
33205   jresult = result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33211   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33212   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33213
33214   arg1 = (Dali::Layer *)jarg1;
33215   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33216   {
33217     try {
33218       (arg1)->SetSortFunction(arg2);
33219     } catch (std::out_of_range& e) {
33220       {
33221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33222       };
33223     } catch (std::exception& e) {
33224       {
33225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33226       };
33227     } catch (...) {
33228       {
33229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33230       };
33231     }
33232   }
33233 }
33234
33235
33236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33237   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33238   bool arg2 ;
33239
33240   arg1 = (Dali::Layer *)jarg1;
33241   arg2 = jarg2 ? true : false;
33242   {
33243     try {
33244       (arg1)->SetTouchConsumed(arg2);
33245     } catch (std::out_of_range& e) {
33246       {
33247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33248       };
33249     } catch (std::exception& e) {
33250       {
33251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33252       };
33253     } catch (...) {
33254       {
33255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33256       };
33257     }
33258   }
33259 }
33260
33261
33262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33263   unsigned int jresult ;
33264   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33265   bool result;
33266
33267   arg1 = (Dali::Layer *)jarg1;
33268   {
33269     try {
33270       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33271     } catch (std::out_of_range& e) {
33272       {
33273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33274       };
33275     } catch (std::exception& e) {
33276       {
33277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33278       };
33279     } catch (...) {
33280       {
33281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33282       };
33283     }
33284   }
33285   jresult = result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33291   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33292   bool arg2 ;
33293
33294   arg1 = (Dali::Layer *)jarg1;
33295   arg2 = jarg2 ? true : false;
33296   {
33297     try {
33298       (arg1)->SetHoverConsumed(arg2);
33299     } catch (std::out_of_range& e) {
33300       {
33301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33302       };
33303     } catch (std::exception& e) {
33304       {
33305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33306       };
33307     } catch (...) {
33308       {
33309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33310       };
33311     }
33312   }
33313 }
33314
33315
33316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33317   unsigned int jresult ;
33318   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33319   bool result;
33320
33321   arg1 = (Dali::Layer *)jarg1;
33322   {
33323     try {
33324       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33325     } catch (std::out_of_range& e) {
33326       {
33327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33328       };
33329     } catch (std::exception& e) {
33330       {
33331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33332       };
33333     } catch (...) {
33334       {
33335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33336       };
33337     }
33338   }
33339   jresult = result;
33340   return jresult;
33341 }
33342
33343
33344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33345   void * jresult ;
33346   Dali::Vector4 *result = 0 ;
33347
33348   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33349   jresult = (void *)result;
33350   return jresult;
33351 }
33352
33353
33354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33355   void * jresult ;
33356   Dali::Vector4 *result = 0 ;
33357
33358   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33359   jresult = (void *)result;
33360   return jresult;
33361 }
33362
33363
33364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33365   void * jresult ;
33366   Dali::Stage *result = 0 ;
33367
33368   {
33369     try {
33370       result = (Dali::Stage *)new Dali::Stage();
33371     } catch (std::out_of_range& e) {
33372       {
33373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33374       };
33375     } catch (std::exception& e) {
33376       {
33377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33378       };
33379     } catch (...) {
33380       {
33381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33382       };
33383     }
33384   }
33385   jresult = (void *)result;
33386   return jresult;
33387 }
33388
33389
33390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33391   void * jresult ;
33392   Dali::Stage result;
33393
33394   {
33395     try {
33396       result = Dali::Stage::GetCurrent();
33397     } catch (std::out_of_range& e) {
33398       {
33399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33400       };
33401     } catch (std::exception& e) {
33402       {
33403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33404       };
33405     } catch (...) {
33406       {
33407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33408       };
33409     }
33410   }
33411   jresult = new Dali::Stage((const Dali::Stage &)result);
33412   return jresult;
33413 }
33414
33415
33416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33417   unsigned int jresult ;
33418   bool result;
33419
33420   {
33421     try {
33422       result = (bool)Dali::Stage::IsInstalled();
33423     } catch (std::out_of_range& e) {
33424       {
33425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33426       };
33427     } catch (std::exception& e) {
33428       {
33429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33430       };
33431     } catch (...) {
33432       {
33433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33434       };
33435     }
33436   }
33437   jresult = result;
33438   return jresult;
33439 }
33440
33441
33442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33443   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33444
33445   arg1 = (Dali::Stage *)jarg1;
33446   {
33447     try {
33448       delete arg1;
33449     } catch (std::out_of_range& e) {
33450       {
33451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33452       };
33453     } catch (std::exception& e) {
33454       {
33455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33456       };
33457     } catch (...) {
33458       {
33459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33460       };
33461     }
33462   }
33463 }
33464
33465
33466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33467   void * jresult ;
33468   Dali::Stage *arg1 = 0 ;
33469   Dali::Stage *result = 0 ;
33470
33471   arg1 = (Dali::Stage *)jarg1;
33472   if (!arg1) {
33473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33474     return 0;
33475   }
33476   {
33477     try {
33478       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33479     } catch (std::out_of_range& e) {
33480       {
33481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33482       };
33483     } catch (std::exception& e) {
33484       {
33485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33486       };
33487     } catch (...) {
33488       {
33489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33490       };
33491     }
33492   }
33493   jresult = (void *)result;
33494   return jresult;
33495 }
33496
33497
33498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33499   void * jresult ;
33500   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33501   Dali::Stage *arg2 = 0 ;
33502   Dali::Stage *result = 0 ;
33503
33504   arg1 = (Dali::Stage *)jarg1;
33505   arg2 = (Dali::Stage *)jarg2;
33506   if (!arg2) {
33507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33508     return 0;
33509   }
33510   {
33511     try {
33512       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33513     } catch (std::out_of_range& e) {
33514       {
33515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33516       };
33517     } catch (std::exception& e) {
33518       {
33519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33520       };
33521     } catch (...) {
33522       {
33523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33524       };
33525     }
33526   }
33527   jresult = (void *)result;
33528   return jresult;
33529 }
33530
33531
33532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33533   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33534   Dali::Actor *arg2 = 0 ;
33535
33536   arg1 = (Dali::Stage *)jarg1;
33537   arg2 = (Dali::Actor *)jarg2;
33538   if (!arg2) {
33539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33540     return ;
33541   }
33542   {
33543     try {
33544       (arg1)->Add(*arg2);
33545     } catch (std::out_of_range& e) {
33546       {
33547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33548       };
33549     } catch (std::exception& e) {
33550       {
33551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33552       };
33553     } catch (...) {
33554       {
33555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33556       };
33557     }
33558   }
33559 }
33560
33561
33562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33563   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33564   Dali::Actor *arg2 = 0 ;
33565
33566   arg1 = (Dali::Stage *)jarg1;
33567   arg2 = (Dali::Actor *)jarg2;
33568   if (!arg2) {
33569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33570     return ;
33571   }
33572   {
33573     try {
33574       (arg1)->Remove(*arg2);
33575     } catch (std::out_of_range& e) {
33576       {
33577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33578       };
33579     } catch (std::exception& e) {
33580       {
33581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33586       };
33587     }
33588   }
33589 }
33590
33591
33592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33593   void * jresult ;
33594   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33595   Dali::Vector2 result;
33596
33597   arg1 = (Dali::Stage *)jarg1;
33598   {
33599     try {
33600       result = ((Dali::Stage const *)arg1)->GetSize();
33601     } catch (std::out_of_range& e) {
33602       {
33603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33604       };
33605     } catch (std::exception& e) {
33606       {
33607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33608       };
33609     } catch (...) {
33610       {
33611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33612       };
33613     }
33614   }
33615   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33616   return jresult;
33617 }
33618
33619
33620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33621   void * jresult ;
33622   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33623   Dali::RenderTaskList result;
33624
33625   arg1 = (Dali::Stage *)jarg1;
33626   {
33627     try {
33628       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33636       };
33637     } catch (...) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33640       };
33641     }
33642   }
33643   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33644   return jresult;
33645 }
33646
33647
33648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33649   unsigned int jresult ;
33650   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33651   unsigned int result;
33652
33653   arg1 = (Dali::Stage *)jarg1;
33654   {
33655     try {
33656       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33657     } catch (std::out_of_range& e) {
33658       {
33659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33660       };
33661     } catch (std::exception& e) {
33662       {
33663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33664       };
33665     } catch (...) {
33666       {
33667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33668       };
33669     }
33670   }
33671   jresult = result;
33672   return jresult;
33673 }
33674
33675
33676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33677   void * jresult ;
33678   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33679   unsigned int arg2 ;
33680   Dali::Layer result;
33681
33682   arg1 = (Dali::Stage *)jarg1;
33683   arg2 = (unsigned int)jarg2;
33684   {
33685     try {
33686       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33687     } catch (std::out_of_range& e) {
33688       {
33689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33690       };
33691     } catch (std::exception& e) {
33692       {
33693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33694       };
33695     } catch (...) {
33696       {
33697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33698       };
33699     }
33700   }
33701   jresult = new Dali::Layer((const Dali::Layer &)result);
33702   return jresult;
33703 }
33704
33705
33706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33707   void * jresult ;
33708   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33709   Dali::Layer result;
33710
33711   arg1 = (Dali::Stage *)jarg1;
33712   {
33713     try {
33714       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33715     } catch (std::out_of_range& e) {
33716       {
33717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33718       };
33719     } catch (std::exception& e) {
33720       {
33721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33722       };
33723     } catch (...) {
33724       {
33725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33726       };
33727     }
33728   }
33729   jresult = new Dali::Layer((const Dali::Layer &)result);
33730   return jresult;
33731 }
33732
33733
33734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33735   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33736   Dali::Vector4 arg2 ;
33737   Dali::Vector4 *argp2 ;
33738
33739   arg1 = (Dali::Stage *)jarg1;
33740   argp2 = (Dali::Vector4 *)jarg2;
33741   if (!argp2) {
33742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33743     return ;
33744   }
33745   arg2 = *argp2;
33746   {
33747     try {
33748       (arg1)->SetBackgroundColor(arg2);
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33756       };
33757     } catch (...) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33760       };
33761     }
33762   }
33763 }
33764
33765
33766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33767   void * jresult ;
33768   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33769   Dali::Vector4 result;
33770
33771   arg1 = (Dali::Stage *)jarg1;
33772   {
33773     try {
33774       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33775     } catch (std::out_of_range& e) {
33776       {
33777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33778       };
33779     } catch (std::exception& e) {
33780       {
33781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33782       };
33783     } catch (...) {
33784       {
33785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33786       };
33787     }
33788   }
33789   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33790   return jresult;
33791 }
33792
33793
33794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33795   void * jresult ;
33796   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33797   Dali::Vector2 result;
33798
33799   arg1 = (Dali::Stage *)jarg1;
33800   {
33801     try {
33802       result = ((Dali::Stage const *)arg1)->GetDpi();
33803     } catch (std::out_of_range& e) {
33804       {
33805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33806       };
33807     } catch (std::exception& e) {
33808       {
33809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (...) {
33812       {
33813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33814       };
33815     }
33816   }
33817   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33818   return jresult;
33819 }
33820
33821
33822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33823   void * jresult ;
33824   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33825   Dali::ObjectRegistry result;
33826
33827   arg1 = (Dali::Stage *)jarg1;
33828   {
33829     try {
33830       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33831     } catch (std::out_of_range& e) {
33832       {
33833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33834       };
33835     } catch (std::exception& e) {
33836       {
33837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33838       };
33839     } catch (...) {
33840       {
33841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33842       };
33843     }
33844   }
33845   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33846   return jresult;
33847 }
33848
33849
33850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33851   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33852   float arg2 ;
33853
33854   arg1 = (Dali::Stage *)jarg1;
33855   arg2 = (float)jarg2;
33856   {
33857     try {
33858       (arg1)->KeepRendering(arg2);
33859     } catch (std::out_of_range& e) {
33860       {
33861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33862       };
33863     } catch (std::exception& e) {
33864       {
33865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33866       };
33867     } catch (...) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33870       };
33871     }
33872   }
33873 }
33874
33875
33876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33877   void * jresult ;
33878   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33879   Dali::Stage::KeyEventSignalType *result = 0 ;
33880
33881   arg1 = (Dali::Stage *)jarg1;
33882   {
33883     try {
33884       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33885     } catch (std::out_of_range& e) {
33886       {
33887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33888       };
33889     } catch (std::exception& e) {
33890       {
33891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33892       };
33893     } catch (...) {
33894       {
33895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33896       };
33897     }
33898   }
33899   jresult = (void *)result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33905   void * jresult ;
33906   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33907   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33908
33909   arg1 = (Dali::Stage *)jarg1;
33910   {
33911     try {
33912       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33913     } catch (std::out_of_range& e) {
33914       {
33915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (std::exception& e) {
33918       {
33919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (...) {
33922       {
33923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33924       };
33925     }
33926   }
33927   jresult = (void *)result;
33928   return jresult;
33929 }
33930
33931
33932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33933   void * jresult ;
33934   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33935   Dali::Stage::TouchSignalType *result = 0 ;
33936
33937   arg1 = (Dali::Stage *)jarg1;
33938   {
33939     try {
33940       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33941     } catch (std::out_of_range& e) {
33942       {
33943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33944       };
33945     } catch (std::exception& e) {
33946       {
33947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33948       };
33949     } catch (...) {
33950       {
33951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33952       };
33953     }
33954   }
33955   jresult = (void *)result;
33956   return jresult;
33957 }
33958
33959
33960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33961   void * jresult ;
33962   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33963   Dali::Stage::WheelEventSignalType *result = 0 ;
33964
33965   arg1 = (Dali::Stage *)jarg1;
33966   {
33967     try {
33968       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33969     } catch (std::out_of_range& e) {
33970       {
33971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33972       };
33973     } catch (std::exception& e) {
33974       {
33975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33976       };
33977     } catch (...) {
33978       {
33979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33980       };
33981     }
33982   }
33983   jresult = (void *)result;
33984   return jresult;
33985 }
33986
33987
33988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33989   void * jresult ;
33990   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33991   Dali::Stage::ContextStatusSignal *result = 0 ;
33992
33993   arg1 = (Dali::Stage *)jarg1;
33994   {
33995     try {
33996       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33997     } catch (std::out_of_range& e) {
33998       {
33999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34000       };
34001     } catch (std::exception& e) {
34002       {
34003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34004       };
34005     } catch (...) {
34006       {
34007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34008       };
34009     }
34010   }
34011   jresult = (void *)result;
34012   return jresult;
34013 }
34014
34015
34016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34017   void * jresult ;
34018   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34019   Dali::Stage::ContextStatusSignal *result = 0 ;
34020
34021   arg1 = (Dali::Stage *)jarg1;
34022   {
34023     try {
34024       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34025     } catch (std::out_of_range& e) {
34026       {
34027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (std::exception& e) {
34030       {
34031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34032       };
34033     } catch (...) {
34034       {
34035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34036       };
34037     }
34038   }
34039   jresult = (void *)result;
34040   return jresult;
34041 }
34042
34043
34044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34045   void * jresult ;
34046   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34047   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34048
34049   arg1 = (Dali::Stage *)jarg1;
34050   {
34051     try {
34052       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34053     } catch (std::out_of_range& e) {
34054       {
34055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34056       };
34057     } catch (std::exception& e) {
34058       {
34059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34060       };
34061     } catch (...) {
34062       {
34063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34064       };
34065     }
34066   }
34067   jresult = (void *)result;
34068   return jresult;
34069 }
34070
34071
34072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34073   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34074
34075   arg1 = (Dali::RelayoutContainer *)jarg1;
34076   {
34077     try {
34078       delete arg1;
34079     } catch (std::out_of_range& e) {
34080       {
34081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34082       };
34083     } catch (std::exception& e) {
34084       {
34085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34086       };
34087     } catch (...) {
34088       {
34089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34090       };
34091     }
34092   }
34093 }
34094
34095
34096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34097   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34098   Dali::Actor *arg2 = 0 ;
34099   Dali::Vector2 *arg3 = 0 ;
34100
34101   arg1 = (Dali::RelayoutContainer *)jarg1;
34102   arg2 = (Dali::Actor *)jarg2;
34103   if (!arg2) {
34104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34105     return ;
34106   }
34107   arg3 = (Dali::Vector2 *)jarg3;
34108   if (!arg3) {
34109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34110     return ;
34111   }
34112   {
34113     try {
34114       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34115     } catch (std::out_of_range& e) {
34116       {
34117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34118       };
34119     } catch (std::exception& e) {
34120       {
34121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34122       };
34123     } catch (...) {
34124       {
34125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34126       };
34127     }
34128   }
34129 }
34130
34131
34132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34133   void * jresult ;
34134   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34135   Dali::CustomActor result;
34136
34137   arg1 = (Dali::CustomActorImpl *)jarg1;
34138   {
34139     try {
34140       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34141     } catch (std::out_of_range& e) {
34142       {
34143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34144       };
34145     } catch (std::exception& e) {
34146       {
34147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34148       };
34149     } catch (...) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34152       };
34153     }
34154   }
34155   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34156   return jresult;
34157 }
34158
34159
34160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34161   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34162   int arg2 ;
34163
34164   arg1 = (Dali::CustomActorImpl *)jarg1;
34165   arg2 = (int)jarg2;
34166   {
34167     try {
34168       (arg1)->OnStageConnection(arg2);
34169     } catch (std::out_of_range& e) {
34170       {
34171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34172       };
34173     } catch (std::exception& e) {
34174       {
34175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34176       };
34177     } catch (...) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34180       };
34181     }
34182   }
34183 }
34184
34185
34186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34187   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34188
34189   arg1 = (Dali::CustomActorImpl *)jarg1;
34190   {
34191     try {
34192       (arg1)->OnStageDisconnection();
34193     } catch (std::out_of_range& e) {
34194       {
34195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34196       };
34197     } catch (std::exception& e) {
34198       {
34199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34200       };
34201     } catch (...) {
34202       {
34203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34204       };
34205     }
34206   }
34207 }
34208
34209
34210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34211   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34212   Dali::Actor *arg2 = 0 ;
34213
34214   arg1 = (Dali::CustomActorImpl *)jarg1;
34215   arg2 = (Dali::Actor *)jarg2;
34216   if (!arg2) {
34217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34218     return ;
34219   }
34220   {
34221     try {
34222       (arg1)->OnChildAdd(*arg2);
34223     } catch (std::out_of_range& e) {
34224       {
34225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34226       };
34227     } catch (std::exception& e) {
34228       {
34229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34230       };
34231     } catch (...) {
34232       {
34233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34234       };
34235     }
34236   }
34237 }
34238
34239
34240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34241   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34242   Dali::Actor *arg2 = 0 ;
34243
34244   arg1 = (Dali::CustomActorImpl *)jarg1;
34245   arg2 = (Dali::Actor *)jarg2;
34246   if (!arg2) {
34247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34248     return ;
34249   }
34250   {
34251     try {
34252       (arg1)->OnChildRemove(*arg2);
34253     } catch (std::out_of_range& e) {
34254       {
34255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34256       };
34257     } catch (std::exception& e) {
34258       {
34259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34260       };
34261     } catch (...) {
34262       {
34263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34264       };
34265     }
34266   }
34267 }
34268
34269
34270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34271   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34272   Dali::Property::Index arg2 ;
34273   Dali::Property::Value arg3 ;
34274   Dali::Property::Value *argp3 ;
34275
34276   arg1 = (Dali::CustomActorImpl *)jarg1;
34277   arg2 = (Dali::Property::Index)jarg2;
34278   argp3 = (Dali::Property::Value *)jarg3;
34279   if (!argp3) {
34280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34281     return ;
34282   }
34283   arg3 = *argp3;
34284   {
34285     try {
34286       (arg1)->OnPropertySet(arg2,arg3);
34287     } catch (std::out_of_range& e) {
34288       {
34289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34290       };
34291     } catch (std::exception& e) {
34292       {
34293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34294       };
34295     } catch (...) {
34296       {
34297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34298       };
34299     }
34300   }
34301 }
34302
34303
34304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34306   Dali::Vector3 *arg2 = 0 ;
34307
34308   arg1 = (Dali::CustomActorImpl *)jarg1;
34309   arg2 = (Dali::Vector3 *)jarg2;
34310   if (!arg2) {
34311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34312     return ;
34313   }
34314   {
34315     try {
34316       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34317     } catch (std::out_of_range& e) {
34318       {
34319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34320       };
34321     } catch (std::exception& e) {
34322       {
34323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34324       };
34325     } catch (...) {
34326       {
34327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34328       };
34329     }
34330   }
34331 }
34332
34333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34334   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34335   Dali::Animation *arg2 = 0 ;
34336   Dali::Vector3 *arg3 = 0 ;
34337
34338   arg1 = (Dali::CustomActorImpl *)jarg1;
34339   arg2 = (Dali::Animation *)jarg2;
34340   if (!arg2) {
34341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34342     return ;
34343   }
34344   arg3 = (Dali::Vector3 *)jarg3;
34345   if (!arg3) {
34346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34347     return ;
34348   }
34349   {
34350     try {
34351       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34352     } catch (std::out_of_range& e) {
34353       {
34354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34355       };
34356     } catch (std::exception& e) {
34357       {
34358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34359       };
34360     } catch (...) {
34361       {
34362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34363       };
34364     }
34365   }
34366 }
34367
34368
34369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34370   unsigned int jresult ;
34371   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34372   Dali::TouchEvent *arg2 = 0 ;
34373   bool result;
34374
34375   arg1 = (Dali::CustomActorImpl *)jarg1;
34376   arg2 = (Dali::TouchEvent *)jarg2;
34377   if (!arg2) {
34378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34379     return 0;
34380   }
34381   {
34382     try {
34383       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34384     } catch (std::out_of_range& e) {
34385       {
34386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34387       };
34388     } catch (std::exception& e) {
34389       {
34390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34391       };
34392     } catch (...) {
34393       {
34394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34395       };
34396     }
34397   }
34398   jresult = result;
34399   return jresult;
34400 }
34401
34402
34403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34404   unsigned int jresult ;
34405   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34406   Dali::HoverEvent *arg2 = 0 ;
34407   bool result;
34408
34409   arg1 = (Dali::CustomActorImpl *)jarg1;
34410   arg2 = (Dali::HoverEvent *)jarg2;
34411   if (!arg2) {
34412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34413     return 0;
34414   }
34415   {
34416     try {
34417       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34418     } catch (std::out_of_range& e) {
34419       {
34420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34421       };
34422     } catch (std::exception& e) {
34423       {
34424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34425       };
34426     } catch (...) {
34427       {
34428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34429       };
34430     }
34431   }
34432   jresult = result;
34433   return jresult;
34434 }
34435
34436
34437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34438   unsigned int jresult ;
34439   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34440   Dali::KeyEvent *arg2 = 0 ;
34441   bool result;
34442
34443   arg1 = (Dali::CustomActorImpl *)jarg1;
34444   arg2 = (Dali::KeyEvent *)jarg2;
34445   if (!arg2) {
34446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34447     return 0;
34448   }
34449   {
34450     try {
34451       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34452     } catch (std::out_of_range& e) {
34453       {
34454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34455       };
34456     } catch (std::exception& e) {
34457       {
34458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34459       };
34460     } catch (...) {
34461       {
34462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34463       };
34464     }
34465   }
34466   jresult = result;
34467   return jresult;
34468 }
34469
34470
34471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34472   unsigned int jresult ;
34473   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34474   Dali::WheelEvent *arg2 = 0 ;
34475   bool result;
34476
34477   arg1 = (Dali::CustomActorImpl *)jarg1;
34478   arg2 = (Dali::WheelEvent *)jarg2;
34479   if (!arg2) {
34480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34481     return 0;
34482   }
34483   {
34484     try {
34485       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34486     } catch (std::out_of_range& e) {
34487       {
34488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34489       };
34490     } catch (std::exception& e) {
34491       {
34492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34493       };
34494     } catch (...) {
34495       {
34496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34497       };
34498     }
34499   }
34500   jresult = result;
34501   return jresult;
34502 }
34503
34504
34505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34506   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34507   Dali::Vector2 *arg2 = 0 ;
34508   Dali::RelayoutContainer *arg3 = 0 ;
34509
34510   arg1 = (Dali::CustomActorImpl *)jarg1;
34511   arg2 = (Dali::Vector2 *)jarg2;
34512   if (!arg2) {
34513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34514     return ;
34515   }
34516   arg3 = (Dali::RelayoutContainer *)jarg3;
34517   if (!arg3) {
34518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34519     return ;
34520   }
34521   {
34522     try {
34523       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34524     } catch (std::out_of_range& e) {
34525       {
34526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34527       };
34528     } catch (std::exception& e) {
34529       {
34530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34531       };
34532     } catch (...) {
34533       {
34534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34535       };
34536     }
34537   }
34538 }
34539
34540
34541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34542   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34543   Dali::ResizePolicy::Type arg2 ;
34544   Dali::Dimension::Type arg3 ;
34545
34546   arg1 = (Dali::CustomActorImpl *)jarg1;
34547   arg2 = (Dali::ResizePolicy::Type)jarg2;
34548   arg3 = (Dali::Dimension::Type)jarg3;
34549   {
34550     try {
34551       (arg1)->OnSetResizePolicy(arg2,arg3);
34552     } catch (std::out_of_range& e) {
34553       {
34554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34555       };
34556     } catch (std::exception& e) {
34557       {
34558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34559       };
34560     } catch (...) {
34561       {
34562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34563       };
34564     }
34565   }
34566 }
34567
34568
34569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34570   void * jresult ;
34571   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34572   Dali::Vector3 result;
34573
34574   arg1 = (Dali::CustomActorImpl *)jarg1;
34575   {
34576     try {
34577       result = (arg1)->GetNaturalSize();
34578     } catch (std::out_of_range& e) {
34579       {
34580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34581       };
34582     } catch (std::exception& e) {
34583       {
34584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34589       };
34590     }
34591   }
34592   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34593   return jresult;
34594 }
34595
34596
34597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34598   float jresult ;
34599   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34600   Dali::Actor *arg2 = 0 ;
34601   Dali::Dimension::Type arg3 ;
34602   float result;
34603
34604   arg1 = (Dali::CustomActorImpl *)jarg1;
34605   arg2 = (Dali::Actor *)jarg2;
34606   if (!arg2) {
34607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34608     return 0;
34609   }
34610   arg3 = (Dali::Dimension::Type)jarg3;
34611   {
34612     try {
34613       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34614     } catch (std::out_of_range& e) {
34615       {
34616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34617       };
34618     } catch (std::exception& e) {
34619       {
34620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34621       };
34622     } catch (...) {
34623       {
34624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34625       };
34626     }
34627   }
34628   jresult = result;
34629   return jresult;
34630 }
34631
34632
34633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34634   float jresult ;
34635   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34636   float arg2 ;
34637   float result;
34638
34639   arg1 = (Dali::CustomActorImpl *)jarg1;
34640   arg2 = (float)jarg2;
34641   {
34642     try {
34643       result = (float)(arg1)->GetHeightForWidth(arg2);
34644     } catch (std::out_of_range& e) {
34645       {
34646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34647       };
34648     } catch (std::exception& e) {
34649       {
34650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34651       };
34652     } catch (...) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34655       };
34656     }
34657   }
34658   jresult = result;
34659   return jresult;
34660 }
34661
34662
34663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34664   float jresult ;
34665   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34666   float arg2 ;
34667   float result;
34668
34669   arg1 = (Dali::CustomActorImpl *)jarg1;
34670   arg2 = (float)jarg2;
34671   {
34672     try {
34673       result = (float)(arg1)->GetWidthForHeight(arg2);
34674     } catch (std::out_of_range& e) {
34675       {
34676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34677       };
34678     } catch (std::exception& e) {
34679       {
34680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34681       };
34682     } catch (...) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34685       };
34686     }
34687   }
34688   jresult = result;
34689   return jresult;
34690 }
34691
34692
34693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34694   unsigned int jresult ;
34695   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34696   Dali::Dimension::Type arg2 ;
34697   bool result;
34698
34699   arg1 = (Dali::CustomActorImpl *)jarg1;
34700   arg2 = (Dali::Dimension::Type)jarg2;
34701   {
34702     try {
34703       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34704     } catch (std::out_of_range& e) {
34705       {
34706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34707       };
34708     } catch (std::exception& e) {
34709       {
34710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34711       };
34712     } catch (...) {
34713       {
34714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34715       };
34716     }
34717   }
34718   jresult = result;
34719   return jresult;
34720 }
34721
34722
34723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34724   unsigned int jresult ;
34725   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34726   bool result;
34727
34728   arg1 = (Dali::CustomActorImpl *)jarg1;
34729   {
34730     try {
34731       result = (bool)(arg1)->RelayoutDependentOnChildren();
34732     } catch (std::out_of_range& e) {
34733       {
34734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34735       };
34736     } catch (std::exception& e) {
34737       {
34738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34739       };
34740     } catch (...) {
34741       {
34742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34743       };
34744     }
34745   }
34746   jresult = result;
34747   return jresult;
34748 }
34749
34750
34751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34752   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34753   Dali::Dimension::Type arg2 ;
34754
34755   arg1 = (Dali::CustomActorImpl *)jarg1;
34756   arg2 = (Dali::Dimension::Type)jarg2;
34757   {
34758     try {
34759       (arg1)->OnCalculateRelayoutSize(arg2);
34760     } catch (std::out_of_range& e) {
34761       {
34762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34763       };
34764     } catch (std::exception& e) {
34765       {
34766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34767       };
34768     } catch (...) {
34769       {
34770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34771       };
34772     }
34773   }
34774 }
34775
34776
34777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34778   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34779   float arg2 ;
34780   Dali::Dimension::Type arg3 ;
34781
34782   arg1 = (Dali::CustomActorImpl *)jarg1;
34783   arg2 = (float)jarg2;
34784   arg3 = (Dali::Dimension::Type)jarg3;
34785   {
34786     try {
34787       (arg1)->OnLayoutNegotiated(arg2,arg3);
34788     } catch (std::out_of_range& e) {
34789       {
34790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34791       };
34792     } catch (std::exception& e) {
34793       {
34794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34795       };
34796     } catch (...) {
34797       {
34798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34799       };
34800     }
34801   }
34802 }
34803
34804
34805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34806   unsigned int jresult ;
34807   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34808   bool result;
34809
34810   arg1 = (Dali::CustomActorImpl *)jarg1;
34811   {
34812     try {
34813       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34814     } catch (std::out_of_range& e) {
34815       {
34816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34817       };
34818     } catch (std::exception& e) {
34819       {
34820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34821       };
34822     } catch (...) {
34823       {
34824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34825       };
34826     }
34827   }
34828   jresult = result;
34829   return jresult;
34830 }
34831
34832
34833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34834   unsigned int jresult ;
34835   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34836   bool result;
34837
34838   arg1 = (Dali::CustomActorImpl *)jarg1;
34839   {
34840     try {
34841       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34842     } catch (std::out_of_range& e) {
34843       {
34844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34845       };
34846     } catch (std::exception& e) {
34847       {
34848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34849       };
34850     } catch (...) {
34851       {
34852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34853       };
34854     }
34855   }
34856   jresult = result;
34857   return jresult;
34858 }
34859
34860
34861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34862   unsigned int jresult ;
34863   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34864   bool result;
34865
34866   arg1 = (Dali::CustomActorImpl *)jarg1;
34867   {
34868     try {
34869       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34870     } catch (std::out_of_range& e) {
34871       {
34872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34873       };
34874     } catch (std::exception& e) {
34875       {
34876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34877       };
34878     } catch (...) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34881       };
34882     }
34883   }
34884   jresult = result;
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34890   unsigned int jresult ;
34891   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34892   bool result;
34893
34894   arg1 = (Dali::CustomActorImpl *)jarg1;
34895   {
34896     try {
34897       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34898     } catch (std::out_of_range& e) {
34899       {
34900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34901       };
34902     } catch (std::exception& e) {
34903       {
34904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34905       };
34906     } catch (...) {
34907       {
34908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34909       };
34910     }
34911   }
34912   jresult = result;
34913   return jresult;
34914 }
34915
34916
34917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34918   void * jresult ;
34919   Dali::CustomActor *result = 0 ;
34920
34921   {
34922     try {
34923       result = (Dali::CustomActor *)new Dali::CustomActor();
34924     } catch (std::out_of_range& e) {
34925       {
34926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34927       };
34928     } catch (std::exception& e) {
34929       {
34930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34931       };
34932     } catch (...) {
34933       {
34934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34935       };
34936     }
34937   }
34938   jresult = (void *)result;
34939   return jresult;
34940 }
34941
34942
34943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34944   void * jresult ;
34945   Dali::BaseHandle arg1 ;
34946   Dali::BaseHandle *argp1 ;
34947   Dali::CustomActor result;
34948
34949   argp1 = (Dali::BaseHandle *)jarg1;
34950   if (!argp1) {
34951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34952     return 0;
34953   }
34954   arg1 = *argp1;
34955   {
34956     try {
34957       result = Dali::CustomActor::DownCast(arg1);
34958     } catch (std::out_of_range& e) {
34959       {
34960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34961       };
34962     } catch (std::exception& e) {
34963       {
34964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34965       };
34966     } catch (...) {
34967       {
34968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34969       };
34970     }
34971   }
34972   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34973   return jresult;
34974 }
34975
34976
34977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34978   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34979
34980   arg1 = (Dali::CustomActor *)jarg1;
34981   {
34982     try {
34983       delete arg1;
34984     } catch (std::out_of_range& e) {
34985       {
34986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34987       };
34988     } catch (std::exception& e) {
34989       {
34990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (...) {
34993       {
34994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34995       };
34996     }
34997   }
34998 }
34999
35000
35001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35002   void * jresult ;
35003   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35004   Dali::CustomActorImpl *result = 0 ;
35005
35006   arg1 = (Dali::CustomActor *)jarg1;
35007   {
35008     try {
35009       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35010     } catch (std::out_of_range& e) {
35011       {
35012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35013       };
35014     } catch (std::exception& e) {
35015       {
35016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35017       };
35018     } catch (...) {
35019       {
35020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35021       };
35022     }
35023   }
35024   jresult = (void *)result;
35025   return jresult;
35026 }
35027
35028
35029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35030   void * jresult ;
35031   Dali::CustomActorImpl *arg1 = 0 ;
35032   Dali::CustomActor *result = 0 ;
35033
35034   arg1 = (Dali::CustomActorImpl *)jarg1;
35035   if (!arg1) {
35036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35037     return 0;
35038   }
35039   {
35040     try {
35041       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35042     } catch (std::out_of_range& e) {
35043       {
35044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35045       };
35046     } catch (std::exception& e) {
35047       {
35048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35049       };
35050     } catch (...) {
35051       {
35052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35053       };
35054     }
35055   }
35056   jresult = (void *)result;
35057   return jresult;
35058 }
35059
35060
35061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35062   void * jresult ;
35063   Dali::CustomActor *arg1 = 0 ;
35064   Dali::CustomActor *result = 0 ;
35065
35066   arg1 = (Dali::CustomActor *)jarg1;
35067   if (!arg1) {
35068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35069     return 0;
35070   }
35071   {
35072     try {
35073       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35074     } catch (std::out_of_range& e) {
35075       {
35076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35077       };
35078     } catch (std::exception& e) {
35079       {
35080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35081       };
35082     } catch (...) {
35083       {
35084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35085       };
35086     }
35087   }
35088   jresult = (void *)result;
35089   return jresult;
35090 }
35091
35092
35093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35094   void * jresult ;
35095   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35096   Dali::CustomActor *arg2 = 0 ;
35097   Dali::CustomActor *result = 0 ;
35098
35099   arg1 = (Dali::CustomActor *)jarg1;
35100   arg2 = (Dali::CustomActor *)jarg2;
35101   if (!arg2) {
35102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35103     return 0;
35104   }
35105   {
35106     try {
35107       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35108     } catch (std::out_of_range& e) {
35109       {
35110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35111       };
35112     } catch (std::exception& e) {
35113       {
35114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35115       };
35116     } catch (...) {
35117       {
35118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35119       };
35120     }
35121   }
35122   jresult = (void *)result;
35123   return jresult;
35124 }
35125
35126
35127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35128   int jresult ;
35129   int result;
35130
35131   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35132   jresult = (int)result;
35133   return jresult;
35134 }
35135
35136
35137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35138   int jresult ;
35139   int result;
35140
35141   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35142   jresult = (int)result;
35143   return jresult;
35144 }
35145
35146
35147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35148   int jresult ;
35149   int result;
35150
35151   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35152   jresult = (int)result;
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35158   int jresult ;
35159   int result;
35160
35161   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35162   jresult = (int)result;
35163   return jresult;
35164 }
35165
35166
35167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35168   int jresult ;
35169   int result;
35170
35171   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35172   jresult = (int)result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35178   int jresult ;
35179   int result;
35180
35181   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35182   jresult = (int)result;
35183   return jresult;
35184 }
35185
35186
35187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35188   int jresult ;
35189   int result;
35190
35191   result = (int)Dali::PanGestureDetector::Property::PANNING;
35192   jresult = (int)result;
35193   return jresult;
35194 }
35195
35196
35197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35198   void * jresult ;
35199   Dali::PanGestureDetector::Property *result = 0 ;
35200
35201   {
35202     try {
35203       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35204     } catch (std::out_of_range& e) {
35205       {
35206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35207       };
35208     } catch (std::exception& e) {
35209       {
35210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35211       };
35212     } catch (...) {
35213       {
35214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35215       };
35216     }
35217   }
35218   jresult = (void *)result;
35219   return jresult;
35220 }
35221
35222
35223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35224   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35225
35226   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35227   {
35228     try {
35229       delete arg1;
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35237       };
35238     } catch (...) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35241       };
35242     }
35243   }
35244 }
35245
35246
35247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35248   void * jresult ;
35249   Dali::Radian *result = 0 ;
35250
35251   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35252   jresult = (void *)result;
35253   return jresult;
35254 }
35255
35256
35257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35258   void * jresult ;
35259   Dali::Radian *result = 0 ;
35260
35261   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35262   jresult = (void *)result;
35263   return jresult;
35264 }
35265
35266
35267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35268   void * jresult ;
35269   Dali::Radian *result = 0 ;
35270
35271   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35272   jresult = (void *)result;
35273   return jresult;
35274 }
35275
35276
35277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35278   void * jresult ;
35279   Dali::Radian *result = 0 ;
35280
35281   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35282   jresult = (void *)result;
35283   return jresult;
35284 }
35285
35286
35287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35288   void * jresult ;
35289   Dali::Radian *result = 0 ;
35290
35291   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35292   jresult = (void *)result;
35293   return jresult;
35294 }
35295
35296
35297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35298   void * jresult ;
35299   Dali::Radian *result = 0 ;
35300
35301   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35302   jresult = (void *)result;
35303   return jresult;
35304 }
35305
35306
35307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35308   void * jresult ;
35309   Dali::Radian *result = 0 ;
35310
35311   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35312   jresult = (void *)result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35318   void * jresult ;
35319   Dali::PanGestureDetector *result = 0 ;
35320
35321   {
35322     try {
35323       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35324     } catch (std::out_of_range& e) {
35325       {
35326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35327       };
35328     } catch (std::exception& e) {
35329       {
35330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35331       };
35332     } catch (...) {
35333       {
35334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35335       };
35336     }
35337   }
35338   jresult = (void *)result;
35339   return jresult;
35340 }
35341
35342
35343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35344   void * jresult ;
35345   Dali::PanGestureDetector result;
35346
35347   {
35348     try {
35349       result = Dali::PanGestureDetector::New();
35350     } catch (std::out_of_range& e) {
35351       {
35352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35353       };
35354     } catch (std::exception& e) {
35355       {
35356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35357       };
35358     } catch (...) {
35359       {
35360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35361       };
35362     }
35363   }
35364   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35365   return jresult;
35366 }
35367
35368
35369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35370   void * jresult ;
35371   Dali::BaseHandle arg1 ;
35372   Dali::BaseHandle *argp1 ;
35373   Dali::PanGestureDetector result;
35374
35375   argp1 = (Dali::BaseHandle *)jarg1;
35376   if (!argp1) {
35377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35378     return 0;
35379   }
35380   arg1 = *argp1;
35381   {
35382     try {
35383       result = Dali::PanGestureDetector::DownCast(arg1);
35384     } catch (std::out_of_range& e) {
35385       {
35386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35387       };
35388     } catch (std::exception& e) {
35389       {
35390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35391       };
35392     } catch (...) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35395       };
35396     }
35397   }
35398   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35399   return jresult;
35400 }
35401
35402
35403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35404   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35405
35406   arg1 = (Dali::PanGestureDetector *)jarg1;
35407   {
35408     try {
35409       delete arg1;
35410     } catch (std::out_of_range& e) {
35411       {
35412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35413       };
35414     } catch (std::exception& e) {
35415       {
35416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35417       };
35418     } catch (...) {
35419       {
35420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35421       };
35422     }
35423   }
35424 }
35425
35426
35427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35428   void * jresult ;
35429   Dali::PanGestureDetector *arg1 = 0 ;
35430   Dali::PanGestureDetector *result = 0 ;
35431
35432   arg1 = (Dali::PanGestureDetector *)jarg1;
35433   if (!arg1) {
35434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35435     return 0;
35436   }
35437   {
35438     try {
35439       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35440     } catch (std::out_of_range& e) {
35441       {
35442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35443       };
35444     } catch (std::exception& e) {
35445       {
35446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35447       };
35448     } catch (...) {
35449       {
35450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35451       };
35452     }
35453   }
35454   jresult = (void *)result;
35455   return jresult;
35456 }
35457
35458
35459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35460   void * jresult ;
35461   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35462   Dali::PanGestureDetector *arg2 = 0 ;
35463   Dali::PanGestureDetector *result = 0 ;
35464
35465   arg1 = (Dali::PanGestureDetector *)jarg1;
35466   arg2 = (Dali::PanGestureDetector *)jarg2;
35467   if (!arg2) {
35468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35469     return 0;
35470   }
35471   {
35472     try {
35473       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35474     } catch (std::out_of_range& e) {
35475       {
35476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (std::exception& e) {
35479       {
35480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35481       };
35482     } catch (...) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35485       };
35486     }
35487   }
35488   jresult = (void *)result;
35489   return jresult;
35490 }
35491
35492
35493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35494   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35495   unsigned int arg2 ;
35496
35497   arg1 = (Dali::PanGestureDetector *)jarg1;
35498   arg2 = (unsigned int)jarg2;
35499   {
35500     try {
35501       (arg1)->SetMinimumTouchesRequired(arg2);
35502     } catch (std::out_of_range& e) {
35503       {
35504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35505       };
35506     } catch (std::exception& e) {
35507       {
35508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35509       };
35510     } catch (...) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35513       };
35514     }
35515   }
35516 }
35517
35518
35519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35520   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35521   unsigned int arg2 ;
35522
35523   arg1 = (Dali::PanGestureDetector *)jarg1;
35524   arg2 = (unsigned int)jarg2;
35525   {
35526     try {
35527       (arg1)->SetMaximumTouchesRequired(arg2);
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35535       };
35536     } catch (...) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35539       };
35540     }
35541   }
35542 }
35543
35544
35545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35546   unsigned int jresult ;
35547   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35548   unsigned int result;
35549
35550   arg1 = (Dali::PanGestureDetector *)jarg1;
35551   {
35552     try {
35553       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35554     } catch (std::out_of_range& e) {
35555       {
35556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35557       };
35558     } catch (std::exception& e) {
35559       {
35560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35561       };
35562     } catch (...) {
35563       {
35564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35565       };
35566     }
35567   }
35568   jresult = result;
35569   return jresult;
35570 }
35571
35572
35573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35574   unsigned int jresult ;
35575   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35576   unsigned int result;
35577
35578   arg1 = (Dali::PanGestureDetector *)jarg1;
35579   {
35580     try {
35581       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35582     } catch (std::out_of_range& e) {
35583       {
35584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35585       };
35586     } catch (std::exception& e) {
35587       {
35588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35589       };
35590     } catch (...) {
35591       {
35592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35593       };
35594     }
35595   }
35596   jresult = result;
35597   return jresult;
35598 }
35599
35600
35601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35602   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35603   Dali::Radian arg2 ;
35604   Dali::Radian arg3 ;
35605   Dali::Radian *argp2 ;
35606   Dali::Radian *argp3 ;
35607
35608   arg1 = (Dali::PanGestureDetector *)jarg1;
35609   argp2 = (Dali::Radian *)jarg2;
35610   if (!argp2) {
35611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35612     return ;
35613   }
35614   arg2 = *argp2;
35615   argp3 = (Dali::Radian *)jarg3;
35616   if (!argp3) {
35617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35618     return ;
35619   }
35620   arg3 = *argp3;
35621   {
35622     try {
35623       (arg1)->AddAngle(arg2,arg3);
35624     } catch (std::out_of_range& e) {
35625       {
35626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35627       };
35628     } catch (std::exception& e) {
35629       {
35630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35631       };
35632     } catch (...) {
35633       {
35634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35635       };
35636     }
35637   }
35638 }
35639
35640
35641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35642   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35643   Dali::Radian arg2 ;
35644   Dali::Radian *argp2 ;
35645
35646   arg1 = (Dali::PanGestureDetector *)jarg1;
35647   argp2 = (Dali::Radian *)jarg2;
35648   if (!argp2) {
35649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35650     return ;
35651   }
35652   arg2 = *argp2;
35653   {
35654     try {
35655       (arg1)->AddAngle(arg2);
35656     } catch (std::out_of_range& e) {
35657       {
35658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35659       };
35660     } catch (std::exception& e) {
35661       {
35662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35663       };
35664     } catch (...) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35667       };
35668     }
35669   }
35670 }
35671
35672
35673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35674   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35675   Dali::Radian arg2 ;
35676   Dali::Radian arg3 ;
35677   Dali::Radian *argp2 ;
35678   Dali::Radian *argp3 ;
35679
35680   arg1 = (Dali::PanGestureDetector *)jarg1;
35681   argp2 = (Dali::Radian *)jarg2;
35682   if (!argp2) {
35683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35684     return ;
35685   }
35686   arg2 = *argp2;
35687   argp3 = (Dali::Radian *)jarg3;
35688   if (!argp3) {
35689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35690     return ;
35691   }
35692   arg3 = *argp3;
35693   {
35694     try {
35695       (arg1)->AddDirection(arg2,arg3);
35696     } catch (std::out_of_range& e) {
35697       {
35698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35699       };
35700     } catch (std::exception& e) {
35701       {
35702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35703       };
35704     } catch (...) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35707       };
35708     }
35709   }
35710 }
35711
35712
35713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35714   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35715   Dali::Radian arg2 ;
35716   Dali::Radian *argp2 ;
35717
35718   arg1 = (Dali::PanGestureDetector *)jarg1;
35719   argp2 = (Dali::Radian *)jarg2;
35720   if (!argp2) {
35721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35722     return ;
35723   }
35724   arg2 = *argp2;
35725   {
35726     try {
35727       (arg1)->AddDirection(arg2);
35728     } catch (std::out_of_range& e) {
35729       {
35730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35731       };
35732     } catch (std::exception& e) {
35733       {
35734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (...) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35739       };
35740     }
35741   }
35742 }
35743
35744
35745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35746   unsigned long jresult ;
35747   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35748   size_t result;
35749
35750   arg1 = (Dali::PanGestureDetector *)jarg1;
35751   {
35752     try {
35753       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35754     } catch (std::out_of_range& e) {
35755       {
35756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35757       };
35758     } catch (std::exception& e) {
35759       {
35760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35761       };
35762     } catch (...) {
35763       {
35764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35765       };
35766     }
35767   }
35768   jresult = (unsigned long)result;
35769   return jresult;
35770 }
35771
35772
35773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35774   void * jresult ;
35775   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35776   size_t arg2 ;
35777   Dali::PanGestureDetector::AngleThresholdPair result;
35778
35779   arg1 = (Dali::PanGestureDetector *)jarg1;
35780   arg2 = (size_t)jarg2;
35781   {
35782     try {
35783       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35784     } catch (std::out_of_range& e) {
35785       {
35786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35787       };
35788     } catch (std::exception& e) {
35789       {
35790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35791       };
35792     } catch (...) {
35793       {
35794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35795       };
35796     }
35797   }
35798   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35799   return jresult;
35800 }
35801
35802
35803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35804   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35805
35806   arg1 = (Dali::PanGestureDetector *)jarg1;
35807   {
35808     try {
35809       (arg1)->ClearAngles();
35810     } catch (std::out_of_range& e) {
35811       {
35812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35813       };
35814     } catch (std::exception& e) {
35815       {
35816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35817       };
35818     } catch (...) {
35819       {
35820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35821       };
35822     }
35823   }
35824 }
35825
35826
35827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35828   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35829   Dali::Radian arg2 ;
35830   Dali::Radian *argp2 ;
35831
35832   arg1 = (Dali::PanGestureDetector *)jarg1;
35833   argp2 = (Dali::Radian *)jarg2;
35834   if (!argp2) {
35835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35836     return ;
35837   }
35838   arg2 = *argp2;
35839   {
35840     try {
35841       (arg1)->RemoveAngle(arg2);
35842     } catch (std::out_of_range& e) {
35843       {
35844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35845       };
35846     } catch (std::exception& e) {
35847       {
35848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35849       };
35850     } catch (...) {
35851       {
35852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35853       };
35854     }
35855   }
35856 }
35857
35858
35859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35860   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35861   Dali::Radian arg2 ;
35862   Dali::Radian *argp2 ;
35863
35864   arg1 = (Dali::PanGestureDetector *)jarg1;
35865   argp2 = (Dali::Radian *)jarg2;
35866   if (!argp2) {
35867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35868     return ;
35869   }
35870   arg2 = *argp2;
35871   {
35872     try {
35873       (arg1)->RemoveDirection(arg2);
35874     } catch (std::out_of_range& e) {
35875       {
35876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35877       };
35878     } catch (std::exception& e) {
35879       {
35880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35881       };
35882     } catch (...) {
35883       {
35884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35885       };
35886     }
35887   }
35888 }
35889
35890
35891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35892   void * jresult ;
35893   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35894   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35895
35896   arg1 = (Dali::PanGestureDetector *)jarg1;
35897   {
35898     try {
35899       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35900     } catch (std::out_of_range& e) {
35901       {
35902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35903       };
35904     } catch (std::exception& e) {
35905       {
35906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35907       };
35908     } catch (...) {
35909       {
35910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35911       };
35912     }
35913   }
35914   jresult = (void *)result;
35915   return jresult;
35916 }
35917
35918
35919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35920   Dali::PanGesture *arg1 = 0 ;
35921
35922   arg1 = (Dali::PanGesture *)jarg1;
35923   if (!arg1) {
35924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35925     return ;
35926   }
35927   {
35928     try {
35929       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35930     } catch (std::out_of_range& e) {
35931       {
35932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35933       };
35934     } catch (std::exception& e) {
35935       {
35936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35937       };
35938     } catch (...) {
35939       {
35940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35941       };
35942     }
35943   }
35944 }
35945
35946
35947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35948   void * jresult ;
35949   Dali::PanGesture *result = 0 ;
35950
35951   {
35952     try {
35953       result = (Dali::PanGesture *)new Dali::PanGesture();
35954     } catch (std::out_of_range& e) {
35955       {
35956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35957       };
35958     } catch (std::exception& e) {
35959       {
35960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35961       };
35962     } catch (...) {
35963       {
35964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35965       };
35966     }
35967   }
35968   jresult = (void *)result;
35969   return jresult;
35970 }
35971
35972
35973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35974   void * jresult ;
35975   Dali::Gesture::State arg1 ;
35976   Dali::PanGesture *result = 0 ;
35977
35978   arg1 = (Dali::Gesture::State)jarg1;
35979   {
35980     try {
35981       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35982     } catch (std::out_of_range& e) {
35983       {
35984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (std::exception& e) {
35987       {
35988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35989       };
35990     } catch (...) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35993       };
35994     }
35995   }
35996   jresult = (void *)result;
35997   return jresult;
35998 }
35999
36000
36001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36002   void * jresult ;
36003   Dali::PanGesture *arg1 = 0 ;
36004   Dali::PanGesture *result = 0 ;
36005
36006   arg1 = (Dali::PanGesture *)jarg1;
36007   if (!arg1) {
36008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36009     return 0;
36010   }
36011   {
36012     try {
36013       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36014     } catch (std::out_of_range& e) {
36015       {
36016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36017       };
36018     } catch (std::exception& e) {
36019       {
36020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36021       };
36022     } catch (...) {
36023       {
36024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36025       };
36026     }
36027   }
36028   jresult = (void *)result;
36029   return jresult;
36030 }
36031
36032
36033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36034   void * jresult ;
36035   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36036   Dali::PanGesture *arg2 = 0 ;
36037   Dali::PanGesture *result = 0 ;
36038
36039   arg1 = (Dali::PanGesture *)jarg1;
36040   arg2 = (Dali::PanGesture *)jarg2;
36041   if (!arg2) {
36042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36043     return 0;
36044   }
36045   {
36046     try {
36047       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36048     } catch (std::out_of_range& e) {
36049       {
36050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36051       };
36052     } catch (std::exception& e) {
36053       {
36054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36055       };
36056     } catch (...) {
36057       {
36058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36059       };
36060     }
36061   }
36062   jresult = (void *)result;
36063   return jresult;
36064 }
36065
36066
36067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36068   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36069
36070   arg1 = (Dali::PanGesture *)jarg1;
36071   {
36072     try {
36073       delete arg1;
36074     } catch (std::out_of_range& e) {
36075       {
36076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36077       };
36078     } catch (std::exception& e) {
36079       {
36080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36081       };
36082     } catch (...) {
36083       {
36084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36085       };
36086     }
36087   }
36088 }
36089
36090
36091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36092   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36093   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36094
36095   arg1 = (Dali::PanGesture *)jarg1;
36096   arg2 = (Dali::Vector2 *)jarg2;
36097   if (arg1) (arg1)->velocity = *arg2;
36098 }
36099
36100
36101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36102   void * jresult ;
36103   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36104   Dali::Vector2 *result = 0 ;
36105
36106   arg1 = (Dali::PanGesture *)jarg1;
36107   result = (Dali::Vector2 *)& ((arg1)->velocity);
36108   jresult = (void *)result;
36109   return jresult;
36110 }
36111
36112
36113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36114   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36115   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36116
36117   arg1 = (Dali::PanGesture *)jarg1;
36118   arg2 = (Dali::Vector2 *)jarg2;
36119   if (arg1) (arg1)->displacement = *arg2;
36120 }
36121
36122
36123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36124   void * jresult ;
36125   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36126   Dali::Vector2 *result = 0 ;
36127
36128   arg1 = (Dali::PanGesture *)jarg1;
36129   result = (Dali::Vector2 *)& ((arg1)->displacement);
36130   jresult = (void *)result;
36131   return jresult;
36132 }
36133
36134
36135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36136   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36137   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36138
36139   arg1 = (Dali::PanGesture *)jarg1;
36140   arg2 = (Dali::Vector2 *)jarg2;
36141   if (arg1) (arg1)->position = *arg2;
36142 }
36143
36144
36145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36146   void * jresult ;
36147   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36148   Dali::Vector2 *result = 0 ;
36149
36150   arg1 = (Dali::PanGesture *)jarg1;
36151   result = (Dali::Vector2 *)& ((arg1)->position);
36152   jresult = (void *)result;
36153   return jresult;
36154 }
36155
36156
36157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36158   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36159   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36160
36161   arg1 = (Dali::PanGesture *)jarg1;
36162   arg2 = (Dali::Vector2 *)jarg2;
36163   if (arg1) (arg1)->screenVelocity = *arg2;
36164 }
36165
36166
36167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36168   void * jresult ;
36169   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36170   Dali::Vector2 *result = 0 ;
36171
36172   arg1 = (Dali::PanGesture *)jarg1;
36173   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36174   jresult = (void *)result;
36175   return jresult;
36176 }
36177
36178
36179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36180   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36181   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36182
36183   arg1 = (Dali::PanGesture *)jarg1;
36184   arg2 = (Dali::Vector2 *)jarg2;
36185   if (arg1) (arg1)->screenDisplacement = *arg2;
36186 }
36187
36188
36189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36190   void * jresult ;
36191   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36192   Dali::Vector2 *result = 0 ;
36193
36194   arg1 = (Dali::PanGesture *)jarg1;
36195   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36196   jresult = (void *)result;
36197   return jresult;
36198 }
36199
36200
36201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36202   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36203   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36204
36205   arg1 = (Dali::PanGesture *)jarg1;
36206   arg2 = (Dali::Vector2 *)jarg2;
36207   if (arg1) (arg1)->screenPosition = *arg2;
36208 }
36209
36210
36211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36212   void * jresult ;
36213   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36214   Dali::Vector2 *result = 0 ;
36215
36216   arg1 = (Dali::PanGesture *)jarg1;
36217   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36218   jresult = (void *)result;
36219   return jresult;
36220 }
36221
36222
36223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36224   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36225   unsigned int arg2 ;
36226
36227   arg1 = (Dali::PanGesture *)jarg1;
36228   arg2 = (unsigned int)jarg2;
36229   if (arg1) (arg1)->numberOfTouches = arg2;
36230 }
36231
36232
36233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36234   unsigned int jresult ;
36235   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36236   unsigned int result;
36237
36238   arg1 = (Dali::PanGesture *)jarg1;
36239   result = (unsigned int) ((arg1)->numberOfTouches);
36240   jresult = result;
36241   return jresult;
36242 }
36243
36244
36245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36246   float jresult ;
36247   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36248   float result;
36249
36250   arg1 = (Dali::PanGesture *)jarg1;
36251   {
36252     try {
36253       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36254     } catch (std::out_of_range& e) {
36255       {
36256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (std::exception& e) {
36259       {
36260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36265       };
36266     }
36267   }
36268   jresult = result;
36269   return jresult;
36270 }
36271
36272
36273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36274   float jresult ;
36275   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36276   float result;
36277
36278   arg1 = (Dali::PanGesture *)jarg1;
36279   {
36280     try {
36281       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36282     } catch (std::out_of_range& e) {
36283       {
36284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36285       };
36286     } catch (std::exception& e) {
36287       {
36288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36289       };
36290     } catch (...) {
36291       {
36292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36293       };
36294     }
36295   }
36296   jresult = result;
36297   return jresult;
36298 }
36299
36300
36301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36302   float jresult ;
36303   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36304   float result;
36305
36306   arg1 = (Dali::PanGesture *)jarg1;
36307   {
36308     try {
36309       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36310     } catch (std::out_of_range& e) {
36311       {
36312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36313       };
36314     } catch (std::exception& e) {
36315       {
36316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36317       };
36318     } catch (...) {
36319       {
36320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36321       };
36322     }
36323   }
36324   jresult = result;
36325   return jresult;
36326 }
36327
36328
36329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36330   float jresult ;
36331   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36332   float result;
36333
36334   arg1 = (Dali::PanGesture *)jarg1;
36335   {
36336     try {
36337       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36338     } catch (std::out_of_range& e) {
36339       {
36340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36341       };
36342     } catch (std::exception& e) {
36343       {
36344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36345       };
36346     } catch (...) {
36347       {
36348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36349       };
36350     }
36351   }
36352   jresult = result;
36353   return jresult;
36354 }
36355
36356
36357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36358   void * jresult ;
36359   Dali::PinchGestureDetector *result = 0 ;
36360
36361   {
36362     try {
36363       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36364     } catch (std::out_of_range& e) {
36365       {
36366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36367       };
36368     } catch (std::exception& e) {
36369       {
36370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36371       };
36372     } catch (...) {
36373       {
36374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36375       };
36376     }
36377   }
36378   jresult = (void *)result;
36379   return jresult;
36380 }
36381
36382
36383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36384   void * jresult ;
36385   Dali::PinchGestureDetector result;
36386
36387   {
36388     try {
36389       result = Dali::PinchGestureDetector::New();
36390     } catch (std::out_of_range& e) {
36391       {
36392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36393       };
36394     } catch (std::exception& e) {
36395       {
36396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36397       };
36398     } catch (...) {
36399       {
36400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36401       };
36402     }
36403   }
36404   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36405   return jresult;
36406 }
36407
36408
36409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36410   void * jresult ;
36411   Dali::BaseHandle arg1 ;
36412   Dali::BaseHandle *argp1 ;
36413   Dali::PinchGestureDetector result;
36414
36415   argp1 = (Dali::BaseHandle *)jarg1;
36416   if (!argp1) {
36417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36418     return 0;
36419   }
36420   arg1 = *argp1;
36421   {
36422     try {
36423       result = Dali::PinchGestureDetector::DownCast(arg1);
36424     } catch (std::out_of_range& e) {
36425       {
36426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (std::exception& e) {
36429       {
36430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36431       };
36432     } catch (...) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36435       };
36436     }
36437   }
36438   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36439   return jresult;
36440 }
36441
36442
36443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36444   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36445
36446   arg1 = (Dali::PinchGestureDetector *)jarg1;
36447   {
36448     try {
36449       delete arg1;
36450     } catch (std::out_of_range& e) {
36451       {
36452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36453       };
36454     } catch (std::exception& e) {
36455       {
36456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36457       };
36458     } catch (...) {
36459       {
36460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36461       };
36462     }
36463   }
36464 }
36465
36466
36467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36468   void * jresult ;
36469   Dali::PinchGestureDetector *arg1 = 0 ;
36470   Dali::PinchGestureDetector *result = 0 ;
36471
36472   arg1 = (Dali::PinchGestureDetector *)jarg1;
36473   if (!arg1) {
36474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36475     return 0;
36476   }
36477   {
36478     try {
36479       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36480     } catch (std::out_of_range& e) {
36481       {
36482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36483       };
36484     } catch (std::exception& e) {
36485       {
36486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36487       };
36488     } catch (...) {
36489       {
36490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36491       };
36492     }
36493   }
36494   jresult = (void *)result;
36495   return jresult;
36496 }
36497
36498
36499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36500   void * jresult ;
36501   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36502   Dali::PinchGestureDetector *arg2 = 0 ;
36503   Dali::PinchGestureDetector *result = 0 ;
36504
36505   arg1 = (Dali::PinchGestureDetector *)jarg1;
36506   arg2 = (Dali::PinchGestureDetector *)jarg2;
36507   if (!arg2) {
36508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36509     return 0;
36510   }
36511   {
36512     try {
36513       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36514     } catch (std::out_of_range& e) {
36515       {
36516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36517       };
36518     } catch (std::exception& e) {
36519       {
36520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36521       };
36522     } catch (...) {
36523       {
36524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36525       };
36526     }
36527   }
36528   jresult = (void *)result;
36529   return jresult;
36530 }
36531
36532
36533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36534   void * jresult ;
36535   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36536   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36537
36538   arg1 = (Dali::PinchGestureDetector *)jarg1;
36539   {
36540     try {
36541       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36542     } catch (std::out_of_range& e) {
36543       {
36544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36545       };
36546     } catch (std::exception& e) {
36547       {
36548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36549       };
36550     } catch (...) {
36551       {
36552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36553       };
36554     }
36555   }
36556   jresult = (void *)result;
36557   return jresult;
36558 }
36559
36560
36561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36562   void * jresult ;
36563   Dali::Gesture::State arg1 ;
36564   Dali::PinchGesture *result = 0 ;
36565
36566   arg1 = (Dali::Gesture::State)jarg1;
36567   {
36568     try {
36569       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36570     } catch (std::out_of_range& e) {
36571       {
36572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36573       };
36574     } catch (std::exception& e) {
36575       {
36576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36577       };
36578     } catch (...) {
36579       {
36580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36581       };
36582     }
36583   }
36584   jresult = (void *)result;
36585   return jresult;
36586 }
36587
36588
36589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36590   void * jresult ;
36591   Dali::PinchGesture *arg1 = 0 ;
36592   Dali::PinchGesture *result = 0 ;
36593
36594   arg1 = (Dali::PinchGesture *)jarg1;
36595   if (!arg1) {
36596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36597     return 0;
36598   }
36599   {
36600     try {
36601       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36602     } catch (std::out_of_range& e) {
36603       {
36604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36605       };
36606     } catch (std::exception& e) {
36607       {
36608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36609       };
36610     } catch (...) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36613       };
36614     }
36615   }
36616   jresult = (void *)result;
36617   return jresult;
36618 }
36619
36620
36621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36622   void * jresult ;
36623   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36624   Dali::PinchGesture *arg2 = 0 ;
36625   Dali::PinchGesture *result = 0 ;
36626
36627   arg1 = (Dali::PinchGesture *)jarg1;
36628   arg2 = (Dali::PinchGesture *)jarg2;
36629   if (!arg2) {
36630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36631     return 0;
36632   }
36633   {
36634     try {
36635       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36636     } catch (std::out_of_range& e) {
36637       {
36638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36639       };
36640     } catch (std::exception& e) {
36641       {
36642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36643       };
36644     } catch (...) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36647       };
36648     }
36649   }
36650   jresult = (void *)result;
36651   return jresult;
36652 }
36653
36654
36655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36656   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36657
36658   arg1 = (Dali::PinchGesture *)jarg1;
36659   {
36660     try {
36661       delete arg1;
36662     } catch (std::out_of_range& e) {
36663       {
36664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36665       };
36666     } catch (std::exception& e) {
36667       {
36668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36669       };
36670     } catch (...) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36673       };
36674     }
36675   }
36676 }
36677
36678
36679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36680   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36681   float arg2 ;
36682
36683   arg1 = (Dali::PinchGesture *)jarg1;
36684   arg2 = (float)jarg2;
36685   if (arg1) (arg1)->scale = arg2;
36686 }
36687
36688
36689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36690   float jresult ;
36691   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36692   float result;
36693
36694   arg1 = (Dali::PinchGesture *)jarg1;
36695   result = (float) ((arg1)->scale);
36696   jresult = result;
36697   return jresult;
36698 }
36699
36700
36701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36702   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36703   float arg2 ;
36704
36705   arg1 = (Dali::PinchGesture *)jarg1;
36706   arg2 = (float)jarg2;
36707   if (arg1) (arg1)->speed = arg2;
36708 }
36709
36710
36711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36712   float jresult ;
36713   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36714   float result;
36715
36716   arg1 = (Dali::PinchGesture *)jarg1;
36717   result = (float) ((arg1)->speed);
36718   jresult = result;
36719   return jresult;
36720 }
36721
36722
36723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36724   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36725   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36726
36727   arg1 = (Dali::PinchGesture *)jarg1;
36728   arg2 = (Dali::Vector2 *)jarg2;
36729   if (arg1) (arg1)->screenCenterPoint = *arg2;
36730 }
36731
36732
36733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36734   void * jresult ;
36735   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36736   Dali::Vector2 *result = 0 ;
36737
36738   arg1 = (Dali::PinchGesture *)jarg1;
36739   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36740   jresult = (void *)result;
36741   return jresult;
36742 }
36743
36744
36745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36746   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36747   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36748
36749   arg1 = (Dali::PinchGesture *)jarg1;
36750   arg2 = (Dali::Vector2 *)jarg2;
36751   if (arg1) (arg1)->localCenterPoint = *arg2;
36752 }
36753
36754
36755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36756   void * jresult ;
36757   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36758   Dali::Vector2 *result = 0 ;
36759
36760   arg1 = (Dali::PinchGesture *)jarg1;
36761   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36762   jresult = (void *)result;
36763   return jresult;
36764 }
36765
36766
36767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36768   void * jresult ;
36769   Dali::TapGestureDetector *result = 0 ;
36770
36771   {
36772     try {
36773       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36774     } catch (std::out_of_range& e) {
36775       {
36776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36777       };
36778     } catch (std::exception& e) {
36779       {
36780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36781       };
36782     } catch (...) {
36783       {
36784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36785       };
36786     }
36787   }
36788   jresult = (void *)result;
36789   return jresult;
36790 }
36791
36792
36793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36794   void * jresult ;
36795   Dali::TapGestureDetector result;
36796
36797   {
36798     try {
36799       result = Dali::TapGestureDetector::New();
36800     } catch (std::out_of_range& e) {
36801       {
36802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36803       };
36804     } catch (std::exception& e) {
36805       {
36806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36807       };
36808     } catch (...) {
36809       {
36810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36811       };
36812     }
36813   }
36814   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36820   void * jresult ;
36821   unsigned int arg1 ;
36822   Dali::TapGestureDetector result;
36823
36824   arg1 = (unsigned int)jarg1;
36825   {
36826     try {
36827       result = Dali::TapGestureDetector::New(arg1);
36828     } catch (std::out_of_range& e) {
36829       {
36830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36831       };
36832     } catch (std::exception& e) {
36833       {
36834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (...) {
36837       {
36838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36839       };
36840     }
36841   }
36842   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36843   return jresult;
36844 }
36845
36846
36847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36848   void * jresult ;
36849   Dali::BaseHandle arg1 ;
36850   Dali::BaseHandle *argp1 ;
36851   Dali::TapGestureDetector result;
36852
36853   argp1 = (Dali::BaseHandle *)jarg1;
36854   if (!argp1) {
36855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36856     return 0;
36857   }
36858   arg1 = *argp1;
36859   {
36860     try {
36861       result = Dali::TapGestureDetector::DownCast(arg1);
36862     } catch (std::out_of_range& e) {
36863       {
36864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36865       };
36866     } catch (std::exception& e) {
36867       {
36868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36869       };
36870     } catch (...) {
36871       {
36872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36873       };
36874     }
36875   }
36876   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36877   return jresult;
36878 }
36879
36880
36881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36882   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36883
36884   arg1 = (Dali::TapGestureDetector *)jarg1;
36885   {
36886     try {
36887       delete arg1;
36888     } catch (std::out_of_range& e) {
36889       {
36890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36891       };
36892     } catch (std::exception& e) {
36893       {
36894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36895       };
36896     } catch (...) {
36897       {
36898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36899       };
36900     }
36901   }
36902 }
36903
36904
36905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36906   void * jresult ;
36907   Dali::TapGestureDetector *arg1 = 0 ;
36908   Dali::TapGestureDetector *result = 0 ;
36909
36910   arg1 = (Dali::TapGestureDetector *)jarg1;
36911   if (!arg1) {
36912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36913     return 0;
36914   }
36915   {
36916     try {
36917       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36918     } catch (std::out_of_range& e) {
36919       {
36920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36921       };
36922     } catch (std::exception& e) {
36923       {
36924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36925       };
36926     } catch (...) {
36927       {
36928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36929       };
36930     }
36931   }
36932   jresult = (void *)result;
36933   return jresult;
36934 }
36935
36936
36937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36938   void * jresult ;
36939   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36940   Dali::TapGestureDetector *arg2 = 0 ;
36941   Dali::TapGestureDetector *result = 0 ;
36942
36943   arg1 = (Dali::TapGestureDetector *)jarg1;
36944   arg2 = (Dali::TapGestureDetector *)jarg2;
36945   if (!arg2) {
36946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36947     return 0;
36948   }
36949   {
36950     try {
36951       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36952     } catch (std::out_of_range& e) {
36953       {
36954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36955       };
36956     } catch (std::exception& e) {
36957       {
36958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36959       };
36960     } catch (...) {
36961       {
36962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36963       };
36964     }
36965   }
36966   jresult = (void *)result;
36967   return jresult;
36968 }
36969
36970
36971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36972   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36973   unsigned int arg2 ;
36974
36975   arg1 = (Dali::TapGestureDetector *)jarg1;
36976   arg2 = (unsigned int)jarg2;
36977   {
36978     try {
36979       (arg1)->SetMinimumTapsRequired(arg2);
36980     } catch (std::out_of_range& e) {
36981       {
36982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36983       };
36984     } catch (std::exception& e) {
36985       {
36986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36987       };
36988     } catch (...) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36991       };
36992     }
36993   }
36994 }
36995
36996
36997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36998   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36999   unsigned int arg2 ;
37000
37001   arg1 = (Dali::TapGestureDetector *)jarg1;
37002   arg2 = (unsigned int)jarg2;
37003   {
37004     try {
37005       (arg1)->SetMaximumTapsRequired(arg2);
37006     } catch (std::out_of_range& e) {
37007       {
37008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37009       };
37010     } catch (std::exception& e) {
37011       {
37012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37017       };
37018     }
37019   }
37020 }
37021
37022
37023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37024   unsigned int jresult ;
37025   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37026   unsigned int result;
37027
37028   arg1 = (Dali::TapGestureDetector *)jarg1;
37029   {
37030     try {
37031       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37032     } catch (std::out_of_range& e) {
37033       {
37034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37035       };
37036     } catch (std::exception& e) {
37037       {
37038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37039       };
37040     } catch (...) {
37041       {
37042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37043       };
37044     }
37045   }
37046   jresult = result;
37047   return jresult;
37048 }
37049
37050
37051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37052   unsigned int jresult ;
37053   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37054   unsigned int result;
37055
37056   arg1 = (Dali::TapGestureDetector *)jarg1;
37057   {
37058     try {
37059       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37060     } catch (std::out_of_range& e) {
37061       {
37062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37063       };
37064     } catch (std::exception& e) {
37065       {
37066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37067       };
37068     } catch (...) {
37069       {
37070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37071       };
37072     }
37073   }
37074   jresult = result;
37075   return jresult;
37076 }
37077
37078
37079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37080   void * jresult ;
37081   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37082   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37083
37084   arg1 = (Dali::TapGestureDetector *)jarg1;
37085   {
37086     try {
37087       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37088     } catch (std::out_of_range& e) {
37089       {
37090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37091       };
37092     } catch (std::exception& e) {
37093       {
37094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37095       };
37096     } catch (...) {
37097       {
37098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37099       };
37100     }
37101   }
37102   jresult = (void *)result;
37103   return jresult;
37104 }
37105
37106
37107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37108   void * jresult ;
37109   Dali::TapGesture *result = 0 ;
37110
37111   {
37112     try {
37113       result = (Dali::TapGesture *)new Dali::TapGesture();
37114     } catch (std::out_of_range& e) {
37115       {
37116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37117       };
37118     } catch (std::exception& e) {
37119       {
37120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37121       };
37122     } catch (...) {
37123       {
37124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37125       };
37126     }
37127   }
37128   jresult = (void *)result;
37129   return jresult;
37130 }
37131
37132
37133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37134   void * jresult ;
37135   Dali::TapGesture *arg1 = 0 ;
37136   Dali::TapGesture *result = 0 ;
37137
37138   arg1 = (Dali::TapGesture *)jarg1;
37139   if (!arg1) {
37140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37141     return 0;
37142   }
37143   {
37144     try {
37145       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37146     } catch (std::out_of_range& e) {
37147       {
37148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37149       };
37150     } catch (std::exception& e) {
37151       {
37152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37153       };
37154     } catch (...) {
37155       {
37156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37157       };
37158     }
37159   }
37160   jresult = (void *)result;
37161   return jresult;
37162 }
37163
37164
37165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37166   void * jresult ;
37167   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37168   Dali::TapGesture *arg2 = 0 ;
37169   Dali::TapGesture *result = 0 ;
37170
37171   arg1 = (Dali::TapGesture *)jarg1;
37172   arg2 = (Dali::TapGesture *)jarg2;
37173   if (!arg2) {
37174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37175     return 0;
37176   }
37177   {
37178     try {
37179       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37180     } catch (std::out_of_range& e) {
37181       {
37182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37183       };
37184     } catch (std::exception& e) {
37185       {
37186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37187       };
37188     } catch (...) {
37189       {
37190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37191       };
37192     }
37193   }
37194   jresult = (void *)result;
37195   return jresult;
37196 }
37197
37198
37199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37200   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37201
37202   arg1 = (Dali::TapGesture *)jarg1;
37203   {
37204     try {
37205       delete arg1;
37206     } catch (std::out_of_range& e) {
37207       {
37208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37209       };
37210     } catch (std::exception& e) {
37211       {
37212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37213       };
37214     } catch (...) {
37215       {
37216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37217       };
37218     }
37219   }
37220 }
37221
37222
37223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37224   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37225   unsigned int arg2 ;
37226
37227   arg1 = (Dali::TapGesture *)jarg1;
37228   arg2 = (unsigned int)jarg2;
37229   if (arg1) (arg1)->numberOfTaps = arg2;
37230 }
37231
37232
37233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37234   unsigned int jresult ;
37235   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37236   unsigned int result;
37237
37238   arg1 = (Dali::TapGesture *)jarg1;
37239   result = (unsigned int) ((arg1)->numberOfTaps);
37240   jresult = result;
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37246   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37247   unsigned int arg2 ;
37248
37249   arg1 = (Dali::TapGesture *)jarg1;
37250   arg2 = (unsigned int)jarg2;
37251   if (arg1) (arg1)->numberOfTouches = arg2;
37252 }
37253
37254
37255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37256   unsigned int jresult ;
37257   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37258   unsigned int result;
37259
37260   arg1 = (Dali::TapGesture *)jarg1;
37261   result = (unsigned int) ((arg1)->numberOfTouches);
37262   jresult = result;
37263   return jresult;
37264 }
37265
37266
37267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37268   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37269   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37270
37271   arg1 = (Dali::TapGesture *)jarg1;
37272   arg2 = (Dali::Vector2 *)jarg2;
37273   if (arg1) (arg1)->screenPoint = *arg2;
37274 }
37275
37276
37277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37278   void * jresult ;
37279   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37280   Dali::Vector2 *result = 0 ;
37281
37282   arg1 = (Dali::TapGesture *)jarg1;
37283   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37284   jresult = (void *)result;
37285   return jresult;
37286 }
37287
37288
37289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37290   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37291   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37292
37293   arg1 = (Dali::TapGesture *)jarg1;
37294   arg2 = (Dali::Vector2 *)jarg2;
37295   if (arg1) (arg1)->localPoint = *arg2;
37296 }
37297
37298
37299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37300   void * jresult ;
37301   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37302   Dali::Vector2 *result = 0 ;
37303
37304   arg1 = (Dali::TapGesture *)jarg1;
37305   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37306   jresult = (void *)result;
37307   return jresult;
37308 }
37309
37310
37311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37312   void * jresult ;
37313   Dali::AlphaFunction *result = 0 ;
37314
37315   {
37316     try {
37317       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37318     } catch (std::out_of_range& e) {
37319       {
37320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37321       };
37322     } catch (std::exception& e) {
37323       {
37324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37325       };
37326     } catch (...) {
37327       {
37328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37329       };
37330     }
37331   }
37332   jresult = (void *)result;
37333   return jresult;
37334 }
37335
37336
37337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37338   void * jresult ;
37339   Dali::AlphaFunction::BuiltinFunction arg1 ;
37340   Dali::AlphaFunction *result = 0 ;
37341
37342   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37343   {
37344     try {
37345       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37346     } catch (std::out_of_range& e) {
37347       {
37348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37349       };
37350     } catch (std::exception& e) {
37351       {
37352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37353       };
37354     } catch (...) {
37355       {
37356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37357       };
37358     }
37359   }
37360   jresult = (void *)result;
37361   return jresult;
37362 }
37363
37364
37365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37366   void * jresult ;
37367   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37368   Dali::AlphaFunction *result = 0 ;
37369
37370   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37371   {
37372     try {
37373       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37374     } catch (std::out_of_range& e) {
37375       {
37376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37377       };
37378     } catch (std::exception& e) {
37379       {
37380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37381       };
37382     } catch (...) {
37383       {
37384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37385       };
37386     }
37387   }
37388   jresult = (void *)result;
37389   return jresult;
37390 }
37391
37392
37393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37394   void * jresult ;
37395   Dali::Vector2 *arg1 = 0 ;
37396   Dali::Vector2 *arg2 = 0 ;
37397   Dali::AlphaFunction *result = 0 ;
37398
37399   arg1 = (Dali::Vector2 *)jarg1;
37400   if (!arg1) {
37401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37402     return 0;
37403   }
37404   arg2 = (Dali::Vector2 *)jarg2;
37405   if (!arg2) {
37406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37407     return 0;
37408   }
37409   {
37410     try {
37411       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37412     } catch (std::out_of_range& e) {
37413       {
37414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37415       };
37416     } catch (std::exception& e) {
37417       {
37418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37419       };
37420     } catch (...) {
37421       {
37422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37423       };
37424     }
37425   }
37426   jresult = (void *)result;
37427   return jresult;
37428 }
37429
37430
37431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37432   void * jresult ;
37433   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37434   Dali::Vector4 result;
37435
37436   arg1 = (Dali::AlphaFunction *)jarg1;
37437   {
37438     try {
37439       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37440     } catch (std::out_of_range& e) {
37441       {
37442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37443       };
37444     } catch (std::exception& e) {
37445       {
37446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37447       };
37448     } catch (...) {
37449       {
37450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37451       };
37452     }
37453   }
37454   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37455   return jresult;
37456 }
37457
37458
37459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37460   void * jresult ;
37461   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37462   Dali::AlphaFunctionPrototype result;
37463
37464   arg1 = (Dali::AlphaFunction *)jarg1;
37465   {
37466     try {
37467       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37468     } catch (std::out_of_range& e) {
37469       {
37470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37471       };
37472     } catch (std::exception& e) {
37473       {
37474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37475       };
37476     } catch (...) {
37477       {
37478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37479       };
37480     }
37481   }
37482   jresult = (void *)result;
37483   return jresult;
37484 }
37485
37486
37487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37488   int jresult ;
37489   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37490   Dali::AlphaFunction::BuiltinFunction result;
37491
37492   arg1 = (Dali::AlphaFunction *)jarg1;
37493   {
37494     try {
37495       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37503       };
37504     } catch (...) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37507       };
37508     }
37509   }
37510   jresult = (int)result;
37511   return jresult;
37512 }
37513
37514
37515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37516   int jresult ;
37517   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37518   Dali::AlphaFunction::Mode result;
37519
37520   arg1 = (Dali::AlphaFunction *)jarg1;
37521   {
37522     try {
37523       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37524     } catch (std::out_of_range& e) {
37525       {
37526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37527       };
37528     } catch (std::exception& e) {
37529       {
37530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37531       };
37532     } catch (...) {
37533       {
37534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37535       };
37536     }
37537   }
37538   jresult = (int)result;
37539   return jresult;
37540 }
37541
37542
37543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37544   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37545
37546   arg1 = (Dali::AlphaFunction *)jarg1;
37547   {
37548     try {
37549       delete arg1;
37550     } catch (std::out_of_range& e) {
37551       {
37552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37553       };
37554     } catch (std::exception& e) {
37555       {
37556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37557       };
37558     } catch (...) {
37559       {
37560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37561       };
37562     }
37563   }
37564 }
37565
37566
37567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37568   void * jresult ;
37569   Dali::KeyFrames result;
37570
37571   {
37572     try {
37573       result = Dali::KeyFrames::New();
37574     } catch (std::out_of_range& e) {
37575       {
37576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37577       };
37578     } catch (std::exception& e) {
37579       {
37580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37581       };
37582     } catch (...) {
37583       {
37584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37585       };
37586     }
37587   }
37588   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37589   return jresult;
37590 }
37591
37592
37593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37594   void * jresult ;
37595   Dali::BaseHandle arg1 ;
37596   Dali::BaseHandle *argp1 ;
37597   Dali::KeyFrames result;
37598
37599   argp1 = (Dali::BaseHandle *)jarg1;
37600   if (!argp1) {
37601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37602     return 0;
37603   }
37604   arg1 = *argp1;
37605   {
37606     try {
37607       result = Dali::KeyFrames::DownCast(arg1);
37608     } catch (std::out_of_range& e) {
37609       {
37610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37611       };
37612     } catch (std::exception& e) {
37613       {
37614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37615       };
37616     } catch (...) {
37617       {
37618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37619       };
37620     }
37621   }
37622   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37623   return jresult;
37624 }
37625
37626
37627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37628   void * jresult ;
37629   Dali::KeyFrames *result = 0 ;
37630
37631   {
37632     try {
37633       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37634     } catch (std::out_of_range& e) {
37635       {
37636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37637       };
37638     } catch (std::exception& e) {
37639       {
37640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37645       };
37646     }
37647   }
37648   jresult = (void *)result;
37649   return jresult;
37650 }
37651
37652
37653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37654   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37655
37656   arg1 = (Dali::KeyFrames *)jarg1;
37657   {
37658     try {
37659       delete arg1;
37660     } catch (std::out_of_range& e) {
37661       {
37662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (std::exception& e) {
37665       {
37666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37667       };
37668     } catch (...) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37671       };
37672     }
37673   }
37674 }
37675
37676
37677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37678   void * jresult ;
37679   Dali::KeyFrames *arg1 = 0 ;
37680   Dali::KeyFrames *result = 0 ;
37681
37682   arg1 = (Dali::KeyFrames *)jarg1;
37683   if (!arg1) {
37684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37685     return 0;
37686   }
37687   {
37688     try {
37689       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37690     } catch (std::out_of_range& e) {
37691       {
37692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37693       };
37694     } catch (std::exception& e) {
37695       {
37696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37697       };
37698     } catch (...) {
37699       {
37700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37701       };
37702     }
37703   }
37704   jresult = (void *)result;
37705   return jresult;
37706 }
37707
37708
37709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37710   void * jresult ;
37711   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37712   Dali::KeyFrames *arg2 = 0 ;
37713   Dali::KeyFrames *result = 0 ;
37714
37715   arg1 = (Dali::KeyFrames *)jarg1;
37716   arg2 = (Dali::KeyFrames *)jarg2;
37717   if (!arg2) {
37718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37719     return 0;
37720   }
37721   {
37722     try {
37723       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37724     } catch (std::out_of_range& e) {
37725       {
37726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37727       };
37728     } catch (std::exception& e) {
37729       {
37730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37731       };
37732     } catch (...) {
37733       {
37734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37735       };
37736     }
37737   }
37738   jresult = (void *)result;
37739   return jresult;
37740 }
37741
37742
37743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37744   int jresult ;
37745   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37746   Dali::Property::Type result;
37747
37748   arg1 = (Dali::KeyFrames *)jarg1;
37749   {
37750     try {
37751       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37752     } catch (std::out_of_range& e) {
37753       {
37754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37755       };
37756     } catch (std::exception& e) {
37757       {
37758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37759       };
37760     } catch (...) {
37761       {
37762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37763       };
37764     }
37765   }
37766   jresult = (int)result;
37767   return jresult;
37768 }
37769
37770
37771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37772   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37773   float arg2 ;
37774   Dali::Property::Value arg3 ;
37775   Dali::Property::Value *argp3 ;
37776
37777   arg1 = (Dali::KeyFrames *)jarg1;
37778   arg2 = (float)jarg2;
37779   argp3 = (Dali::Property::Value *)jarg3;
37780   if (!argp3) {
37781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37782     return ;
37783   }
37784   arg3 = *argp3;
37785   {
37786     try {
37787       (arg1)->Add(arg2,arg3);
37788     } catch (std::out_of_range& e) {
37789       {
37790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37791       };
37792     } catch (std::exception& e) {
37793       {
37794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37795       };
37796     } catch (...) {
37797       {
37798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37799       };
37800     }
37801   }
37802 }
37803
37804
37805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37806   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37807   float arg2 ;
37808   Dali::Property::Value arg3 ;
37809   Dali::AlphaFunction arg4 ;
37810   Dali::Property::Value *argp3 ;
37811   Dali::AlphaFunction *argp4 ;
37812
37813   arg1 = (Dali::KeyFrames *)jarg1;
37814   arg2 = (float)jarg2;
37815   argp3 = (Dali::Property::Value *)jarg3;
37816   if (!argp3) {
37817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37818     return ;
37819   }
37820   arg3 = *argp3;
37821   argp4 = (Dali::AlphaFunction *)jarg4;
37822   if (!argp4) {
37823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37824     return ;
37825   }
37826   arg4 = *argp4;
37827   {
37828     try {
37829       (arg1)->Add(arg2,arg3,arg4);
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37837       };
37838     } catch (...) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37841       };
37842     }
37843   }
37844 }
37845
37846
37847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37848   int jresult ;
37849   int result;
37850
37851   result = (int)Dali::Path::Property::POINTS;
37852   jresult = (int)result;
37853   return jresult;
37854 }
37855
37856
37857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37858   int jresult ;
37859   int result;
37860
37861   result = (int)Dali::Path::Property::CONTROL_POINTS;
37862   jresult = (int)result;
37863   return jresult;
37864 }
37865
37866
37867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37868   void * jresult ;
37869   Dali::Path::Property *result = 0 ;
37870
37871   {
37872     try {
37873       result = (Dali::Path::Property *)new Dali::Path::Property();
37874     } catch (std::out_of_range& e) {
37875       {
37876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37877       };
37878     } catch (std::exception& e) {
37879       {
37880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37881       };
37882     } catch (...) {
37883       {
37884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37885       };
37886     }
37887   }
37888   jresult = (void *)result;
37889   return jresult;
37890 }
37891
37892
37893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37894   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37895
37896   arg1 = (Dali::Path::Property *)jarg1;
37897   {
37898     try {
37899       delete arg1;
37900     } catch (std::out_of_range& e) {
37901       {
37902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37903       };
37904     } catch (std::exception& e) {
37905       {
37906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37907       };
37908     } catch (...) {
37909       {
37910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37911       };
37912     }
37913   }
37914 }
37915
37916
37917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37918   void * jresult ;
37919   Dali::Path result;
37920
37921   {
37922     try {
37923       result = Dali::Path::New();
37924     } catch (std::out_of_range& e) {
37925       {
37926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37927       };
37928     } catch (std::exception& e) {
37929       {
37930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37931       };
37932     } catch (...) {
37933       {
37934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37935       };
37936     }
37937   }
37938   jresult = new Dali::Path((const Dali::Path &)result);
37939   return jresult;
37940 }
37941
37942
37943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37944   void * jresult ;
37945   Dali::BaseHandle arg1 ;
37946   Dali::BaseHandle *argp1 ;
37947   Dali::Path result;
37948
37949   argp1 = (Dali::BaseHandle *)jarg1;
37950   if (!argp1) {
37951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37952     return 0;
37953   }
37954   arg1 = *argp1;
37955   {
37956     try {
37957       result = Dali::Path::DownCast(arg1);
37958     } catch (std::out_of_range& e) {
37959       {
37960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37961       };
37962     } catch (std::exception& e) {
37963       {
37964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37965       };
37966     } catch (...) {
37967       {
37968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37969       };
37970     }
37971   }
37972   jresult = new Dali::Path((const Dali::Path &)result);
37973   return jresult;
37974 }
37975
37976
37977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37978   void * jresult ;
37979   Dali::Path *result = 0 ;
37980
37981   {
37982     try {
37983       result = (Dali::Path *)new Dali::Path();
37984     } catch (std::out_of_range& e) {
37985       {
37986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37987       };
37988     } catch (std::exception& e) {
37989       {
37990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37991       };
37992     } catch (...) {
37993       {
37994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37995       };
37996     }
37997   }
37998   jresult = (void *)result;
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38004   Dali::Path *arg1 = (Dali::Path *) 0 ;
38005
38006   arg1 = (Dali::Path *)jarg1;
38007   {
38008     try {
38009       delete arg1;
38010     } catch (std::out_of_range& e) {
38011       {
38012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38013       };
38014     } catch (std::exception& e) {
38015       {
38016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38017       };
38018     } catch (...) {
38019       {
38020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38021       };
38022     }
38023   }
38024 }
38025
38026
38027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38028   void * jresult ;
38029   Dali::Path *arg1 = 0 ;
38030   Dali::Path *result = 0 ;
38031
38032   arg1 = (Dali::Path *)jarg1;
38033   if (!arg1) {
38034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38035     return 0;
38036   }
38037   {
38038     try {
38039       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38040     } catch (std::out_of_range& e) {
38041       {
38042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38043       };
38044     } catch (std::exception& e) {
38045       {
38046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38047       };
38048     } catch (...) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38051       };
38052     }
38053   }
38054   jresult = (void *)result;
38055   return jresult;
38056 }
38057
38058
38059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38060   void * jresult ;
38061   Dali::Path *arg1 = (Dali::Path *) 0 ;
38062   Dali::Path *arg2 = 0 ;
38063   Dali::Path *result = 0 ;
38064
38065   arg1 = (Dali::Path *)jarg1;
38066   arg2 = (Dali::Path *)jarg2;
38067   if (!arg2) {
38068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38069     return 0;
38070   }
38071   {
38072     try {
38073       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38074     } catch (std::out_of_range& e) {
38075       {
38076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38077       };
38078     } catch (std::exception& e) {
38079       {
38080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38081       };
38082     } catch (...) {
38083       {
38084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38085       };
38086     }
38087   }
38088   jresult = (void *)result;
38089   return jresult;
38090 }
38091
38092
38093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38094   Dali::Path *arg1 = (Dali::Path *) 0 ;
38095   Dali::Vector3 *arg2 = 0 ;
38096
38097   arg1 = (Dali::Path *)jarg1;
38098   arg2 = (Dali::Vector3 *)jarg2;
38099   if (!arg2) {
38100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38101     return ;
38102   }
38103   {
38104     try {
38105       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38106     } catch (std::out_of_range& e) {
38107       {
38108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38109       };
38110     } catch (std::exception& e) {
38111       {
38112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38113       };
38114     } catch (...) {
38115       {
38116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38117       };
38118     }
38119   }
38120 }
38121
38122
38123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38124   Dali::Path *arg1 = (Dali::Path *) 0 ;
38125   Dali::Vector3 *arg2 = 0 ;
38126
38127   arg1 = (Dali::Path *)jarg1;
38128   arg2 = (Dali::Vector3 *)jarg2;
38129   if (!arg2) {
38130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38131     return ;
38132   }
38133   {
38134     try {
38135       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38136     } catch (std::out_of_range& e) {
38137       {
38138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38139       };
38140     } catch (std::exception& e) {
38141       {
38142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38143       };
38144     } catch (...) {
38145       {
38146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38147       };
38148     }
38149   }
38150 }
38151
38152
38153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38154   Dali::Path *arg1 = (Dali::Path *) 0 ;
38155   float arg2 ;
38156
38157   arg1 = (Dali::Path *)jarg1;
38158   arg2 = (float)jarg2;
38159   {
38160     try {
38161       (arg1)->GenerateControlPoints(arg2);
38162     } catch (std::out_of_range& e) {
38163       {
38164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38165       };
38166     } catch (std::exception& e) {
38167       {
38168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38169       };
38170     } catch (...) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38173       };
38174     }
38175   }
38176 }
38177
38178
38179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38180   Dali::Path *arg1 = (Dali::Path *) 0 ;
38181   float arg2 ;
38182   Dali::Vector3 *arg3 = 0 ;
38183   Dali::Vector3 *arg4 = 0 ;
38184
38185   arg1 = (Dali::Path *)jarg1;
38186   arg2 = (float)jarg2;
38187   arg3 = (Dali::Vector3 *)jarg3;
38188   if (!arg3) {
38189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38190     return ;
38191   }
38192   arg4 = (Dali::Vector3 *)jarg4;
38193   if (!arg4) {
38194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38195     return ;
38196   }
38197   {
38198     try {
38199       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38200     } catch (std::out_of_range& e) {
38201       {
38202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38203       };
38204     } catch (std::exception& e) {
38205       {
38206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38207       };
38208     } catch (...) {
38209       {
38210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38211       };
38212     }
38213   }
38214 }
38215
38216
38217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38218   void * jresult ;
38219   Dali::Path *arg1 = (Dali::Path *) 0 ;
38220   size_t arg2 ;
38221   Dali::Vector3 *result = 0 ;
38222
38223   arg1 = (Dali::Path *)jarg1;
38224   arg2 = (size_t)jarg2;
38225   {
38226     try {
38227       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38228     } catch (std::out_of_range& e) {
38229       {
38230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38231       };
38232     } catch (std::exception& e) {
38233       {
38234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38235       };
38236     } catch (...) {
38237       {
38238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38239       };
38240     }
38241   }
38242   jresult = (void *)result;
38243   return jresult;
38244 }
38245
38246
38247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38248   void * jresult ;
38249   Dali::Path *arg1 = (Dali::Path *) 0 ;
38250   size_t arg2 ;
38251   Dali::Vector3 *result = 0 ;
38252
38253   arg1 = (Dali::Path *)jarg1;
38254   arg2 = (size_t)jarg2;
38255   {
38256     try {
38257       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38258     } catch (std::out_of_range& e) {
38259       {
38260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38261       };
38262     } catch (std::exception& e) {
38263       {
38264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38265       };
38266     } catch (...) {
38267       {
38268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38269       };
38270     }
38271   }
38272   jresult = (void *)result;
38273   return jresult;
38274 }
38275
38276
38277 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38278   unsigned long jresult ;
38279   Dali::Path *arg1 = (Dali::Path *) 0 ;
38280   size_t result;
38281
38282   arg1 = (Dali::Path *)jarg1;
38283   {
38284     try {
38285       result = ((Dali::Path const *)arg1)->GetPointCount();
38286     } catch (std::out_of_range& e) {
38287       {
38288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38289       };
38290     } catch (std::exception& e) {
38291       {
38292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38293       };
38294     } catch (...) {
38295       {
38296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38297       };
38298     }
38299   }
38300   jresult = (unsigned long)result;
38301   return jresult;
38302 }
38303
38304
38305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38306   void * jresult ;
38307   float arg1 ;
38308   Dali::TimePeriod *result = 0 ;
38309
38310   arg1 = (float)jarg1;
38311   {
38312     try {
38313       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38314     } catch (std::out_of_range& e) {
38315       {
38316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38317       };
38318     } catch (std::exception& e) {
38319       {
38320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38321       };
38322     } catch (...) {
38323       {
38324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38325       };
38326     }
38327   }
38328   jresult = (void *)result;
38329   return jresult;
38330 }
38331
38332
38333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38334   void * jresult ;
38335   float arg1 ;
38336   float arg2 ;
38337   Dali::TimePeriod *result = 0 ;
38338
38339   arg1 = (float)jarg1;
38340   arg2 = (float)jarg2;
38341   {
38342     try {
38343       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38344     } catch (std::out_of_range& e) {
38345       {
38346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38347       };
38348     } catch (std::exception& e) {
38349       {
38350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38351       };
38352     } catch (...) {
38353       {
38354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38355       };
38356     }
38357   }
38358   jresult = (void *)result;
38359   return jresult;
38360 }
38361
38362
38363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38364   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38365
38366   arg1 = (Dali::TimePeriod *)jarg1;
38367   {
38368     try {
38369       delete arg1;
38370     } catch (std::out_of_range& e) {
38371       {
38372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38373       };
38374     } catch (std::exception& e) {
38375       {
38376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38377       };
38378     } catch (...) {
38379       {
38380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38381       };
38382     }
38383   }
38384 }
38385
38386
38387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38388   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38389   float arg2 ;
38390
38391   arg1 = (Dali::TimePeriod *)jarg1;
38392   arg2 = (float)jarg2;
38393   if (arg1) (arg1)->delaySeconds = arg2;
38394 }
38395
38396
38397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38398   float jresult ;
38399   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38400   float result;
38401
38402   arg1 = (Dali::TimePeriod *)jarg1;
38403   result = (float) ((arg1)->delaySeconds);
38404   jresult = result;
38405   return jresult;
38406 }
38407
38408
38409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38410   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38411   float arg2 ;
38412
38413   arg1 = (Dali::TimePeriod *)jarg1;
38414   arg2 = (float)jarg2;
38415   if (arg1) (arg1)->durationSeconds = arg2;
38416 }
38417
38418
38419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38420   float jresult ;
38421   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38422   float result;
38423
38424   arg1 = (Dali::TimePeriod *)jarg1;
38425   result = (float) ((arg1)->durationSeconds);
38426   jresult = result;
38427   return jresult;
38428 }
38429
38430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
38431   int jresult ;
38432   int result;
38433
38434   result = (int)Dali::LinearConstrainer::Property::VALUE;
38435   jresult = (int)result;
38436   return jresult;
38437 }
38438
38439
38440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
38441   int jresult ;
38442   int result;
38443
38444   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
38445   jresult = (int)result;
38446   return jresult;
38447 }
38448
38449
38450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
38451   void * jresult ;
38452   Dali::LinearConstrainer::Property *result = 0 ;
38453
38454   {
38455     try {
38456       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
38457     } catch (std::out_of_range& e) {
38458       {
38459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38460       };
38461     } catch (std::exception& e) {
38462       {
38463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38464       };
38465     } catch (...) {
38466       {
38467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38468       };
38469     }
38470   }
38471   jresult = (void *)result;
38472   return jresult;
38473 }
38474
38475
38476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
38477   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
38478
38479   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
38480   {
38481     try {
38482       delete arg1;
38483     } catch (std::out_of_range& e) {
38484       {
38485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38486       };
38487     } catch (std::exception& e) {
38488       {
38489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38490       };
38491     } catch (...) {
38492       {
38493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38494       };
38495     }
38496   }
38497 }
38498
38499
38500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
38501   void * jresult ;
38502   Dali::LinearConstrainer result;
38503
38504   {
38505     try {
38506       result = Dali::LinearConstrainer::New();
38507     } catch (std::out_of_range& e) {
38508       {
38509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38510       };
38511     } catch (std::exception& e) {
38512       {
38513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38514       };
38515     } catch (...) {
38516       {
38517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38518       };
38519     }
38520   }
38521   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38522   return jresult;
38523 }
38524
38525
38526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
38527   void * jresult ;
38528   Dali::BaseHandle arg1 ;
38529   Dali::BaseHandle *argp1 ;
38530   Dali::LinearConstrainer result;
38531
38532   argp1 = (Dali::BaseHandle *)jarg1;
38533   if (!argp1) {
38534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38535     return 0;
38536   }
38537   arg1 = *argp1;
38538   {
38539     try {
38540       result = Dali::LinearConstrainer::DownCast(arg1);
38541     } catch (std::out_of_range& e) {
38542       {
38543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (std::exception& e) {
38546       {
38547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
38556   return jresult;
38557 }
38558
38559
38560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
38561   void * jresult ;
38562   Dali::LinearConstrainer *result = 0 ;
38563
38564   {
38565     try {
38566       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
38567     } catch (std::out_of_range& e) {
38568       {
38569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (std::exception& e) {
38572       {
38573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581   jresult = (void *)result;
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
38587   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38588
38589   arg1 = (Dali::LinearConstrainer *)jarg1;
38590   {
38591     try {
38592       delete arg1;
38593     } catch (std::out_of_range& e) {
38594       {
38595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38596       };
38597     } catch (std::exception& e) {
38598       {
38599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38600       };
38601     } catch (...) {
38602       {
38603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38604       };
38605     }
38606   }
38607 }
38608
38609
38610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
38611   void * jresult ;
38612   Dali::LinearConstrainer *arg1 = 0 ;
38613   Dali::LinearConstrainer *result = 0 ;
38614
38615   arg1 = (Dali::LinearConstrainer *)jarg1;
38616   if (!arg1) {
38617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38618     return 0;
38619   }
38620   {
38621     try {
38622       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
38623     } catch (std::out_of_range& e) {
38624       {
38625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38626       };
38627     } catch (std::exception& e) {
38628       {
38629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38630       };
38631     } catch (...) {
38632       {
38633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38634       };
38635     }
38636   }
38637   jresult = (void *)result;
38638   return jresult;
38639 }
38640
38641
38642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
38643   void * jresult ;
38644   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38645   Dali::LinearConstrainer *arg2 = 0 ;
38646   Dali::LinearConstrainer *result = 0 ;
38647
38648   arg1 = (Dali::LinearConstrainer *)jarg1;
38649   arg2 = (Dali::LinearConstrainer *)jarg2;
38650   if (!arg2) {
38651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
38652     return 0;
38653   }
38654   {
38655     try {
38656       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
38657     } catch (std::out_of_range& e) {
38658       {
38659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38660       };
38661     } catch (std::exception& e) {
38662       {
38663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38668       };
38669     }
38670   }
38671   jresult = (void *)result;
38672   return jresult;
38673 }
38674
38675
38676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
38677   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38678   SwigValueWrapper< Dali::Property > arg2 ;
38679   SwigValueWrapper< Dali::Property > arg3 ;
38680   Dali::Vector2 *arg4 = 0 ;
38681   Dali::Vector2 *arg5 = 0 ;
38682   Dali::Property *argp2 ;
38683   Dali::Property *argp3 ;
38684
38685   arg1 = (Dali::LinearConstrainer *)jarg1;
38686   argp2 = (Dali::Property *)jarg2;
38687   if (!argp2) {
38688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38689     return ;
38690   }
38691   arg2 = *argp2;
38692   argp3 = (Dali::Property *)jarg3;
38693   if (!argp3) {
38694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38695     return ;
38696   }
38697   arg3 = *argp3;
38698   arg4 = (Dali::Vector2 *)jarg4;
38699   if (!arg4) {
38700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38701     return ;
38702   }
38703   arg5 = (Dali::Vector2 *)jarg5;
38704   if (!arg5) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38706     return ;
38707   }
38708   {
38709     try {
38710       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
38711     } catch (std::out_of_range& e) {
38712       {
38713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38714       };
38715     } catch (std::exception& e) {
38716       {
38717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38718       };
38719     } catch (...) {
38720       {
38721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38722       };
38723     }
38724   }
38725 }
38726
38727
38728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
38729   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38730   SwigValueWrapper< Dali::Property > arg2 ;
38731   SwigValueWrapper< Dali::Property > arg3 ;
38732   Dali::Vector2 *arg4 = 0 ;
38733   Dali::Property *argp2 ;
38734   Dali::Property *argp3 ;
38735
38736   arg1 = (Dali::LinearConstrainer *)jarg1;
38737   argp2 = (Dali::Property *)jarg2;
38738   if (!argp2) {
38739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38740     return ;
38741   }
38742   arg2 = *argp2;
38743   argp3 = (Dali::Property *)jarg3;
38744   if (!argp3) {
38745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
38746     return ;
38747   }
38748   arg3 = *argp3;
38749   arg4 = (Dali::Vector2 *)jarg4;
38750   if (!arg4) {
38751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38752     return ;
38753   }
38754   {
38755     try {
38756       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
38757     } catch (std::out_of_range& e) {
38758       {
38759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38760       };
38761     } catch (std::exception& e) {
38762       {
38763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38764       };
38765     } catch (...) {
38766       {
38767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38768       };
38769     }
38770   }
38771 }
38772
38773
38774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
38775   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
38776   Dali::Handle *arg2 = 0 ;
38777
38778   arg1 = (Dali::LinearConstrainer *)jarg1;
38779   arg2 = (Dali::Handle *)jarg2;
38780   if (!arg2) {
38781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
38782     return ;
38783   }
38784   {
38785     try {
38786       (arg1)->Remove(*arg2);
38787     } catch (std::out_of_range& e) {
38788       {
38789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38790       };
38791     } catch (std::exception& e) {
38792       {
38793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38794       };
38795     } catch (...) {
38796       {
38797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38798       };
38799     }
38800   }
38801 }
38802
38803
38804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
38805   int jresult ;
38806   int result;
38807
38808   result = (int)Dali::PathConstrainer::Property::FORWARD;
38809   jresult = (int)result;
38810   return jresult;
38811 }
38812
38813
38814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
38815   int jresult ;
38816   int result;
38817
38818   result = (int)Dali::PathConstrainer::Property::POINTS;
38819   jresult = (int)result;
38820   return jresult;
38821 }
38822
38823
38824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
38825   int jresult ;
38826   int result;
38827
38828   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
38829   jresult = (int)result;
38830   return jresult;
38831 }
38832
38833
38834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
38835   void * jresult ;
38836   Dali::PathConstrainer::Property *result = 0 ;
38837
38838   {
38839     try {
38840       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
38841     } catch (std::out_of_range& e) {
38842       {
38843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38844       };
38845     } catch (std::exception& e) {
38846       {
38847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38848       };
38849     } catch (...) {
38850       {
38851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38852       };
38853     }
38854   }
38855   jresult = (void *)result;
38856   return jresult;
38857 }
38858
38859
38860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
38861   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
38862
38863   arg1 = (Dali::PathConstrainer::Property *)jarg1;
38864   {
38865     try {
38866       delete arg1;
38867     } catch (std::out_of_range& e) {
38868       {
38869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38870       };
38871     } catch (std::exception& e) {
38872       {
38873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38874       };
38875     } catch (...) {
38876       {
38877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38878       };
38879     }
38880   }
38881 }
38882
38883
38884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
38885   void * jresult ;
38886   Dali::PathConstrainer result;
38887
38888   {
38889     try {
38890       result = Dali::PathConstrainer::New();
38891     } catch (std::out_of_range& e) {
38892       {
38893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38894       };
38895     } catch (std::exception& e) {
38896       {
38897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38902       };
38903     }
38904   }
38905   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38906   return jresult;
38907 }
38908
38909
38910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
38911   void * jresult ;
38912   Dali::BaseHandle arg1 ;
38913   Dali::BaseHandle *argp1 ;
38914   Dali::PathConstrainer result;
38915
38916   argp1 = (Dali::BaseHandle *)jarg1;
38917   if (!argp1) {
38918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38919     return 0;
38920   }
38921   arg1 = *argp1;
38922   {
38923     try {
38924       result = Dali::PathConstrainer::DownCast(arg1);
38925     } catch (std::out_of_range& e) {
38926       {
38927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38928       };
38929     } catch (std::exception& e) {
38930       {
38931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38932       };
38933     } catch (...) {
38934       {
38935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38936       };
38937     }
38938   }
38939   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
38940   return jresult;
38941 }
38942
38943
38944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
38945   void * jresult ;
38946   Dali::PathConstrainer *result = 0 ;
38947
38948   {
38949     try {
38950       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
38951     } catch (std::out_of_range& e) {
38952       {
38953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38954       };
38955     } catch (std::exception& e) {
38956       {
38957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38958       };
38959     } catch (...) {
38960       {
38961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38962       };
38963     }
38964   }
38965   jresult = (void *)result;
38966   return jresult;
38967 }
38968
38969
38970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
38971   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
38972
38973   arg1 = (Dali::PathConstrainer *)jarg1;
38974   {
38975     try {
38976       delete arg1;
38977     } catch (std::out_of_range& e) {
38978       {
38979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38980       };
38981     } catch (std::exception& e) {
38982       {
38983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38984       };
38985     } catch (...) {
38986       {
38987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38988       };
38989     }
38990   }
38991 }
38992
38993
38994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
38995   void * jresult ;
38996   Dali::PathConstrainer *arg1 = 0 ;
38997   Dali::PathConstrainer *result = 0 ;
38998
38999   arg1 = (Dali::PathConstrainer *)jarg1;
39000   if (!arg1) {
39001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39002     return 0;
39003   }
39004   {
39005     try {
39006       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
39007     } catch (std::out_of_range& e) {
39008       {
39009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39010       };
39011     } catch (std::exception& e) {
39012       {
39013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39014       };
39015     } catch (...) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39018       };
39019     }
39020   }
39021   jresult = (void *)result;
39022   return jresult;
39023 }
39024
39025
39026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
39027   void * jresult ;
39028   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39029   Dali::PathConstrainer *arg2 = 0 ;
39030   Dali::PathConstrainer *result = 0 ;
39031
39032   arg1 = (Dali::PathConstrainer *)jarg1;
39033   arg2 = (Dali::PathConstrainer *)jarg2;
39034   if (!arg2) {
39035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
39036     return 0;
39037   }
39038   {
39039     try {
39040       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
39041     } catch (std::out_of_range& e) {
39042       {
39043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39044       };
39045     } catch (std::exception& e) {
39046       {
39047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39048       };
39049     } catch (...) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39052       };
39053     }
39054   }
39055   jresult = (void *)result;
39056   return jresult;
39057 }
39058
39059
39060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39061   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39062   SwigValueWrapper< Dali::Property > arg2 ;
39063   SwigValueWrapper< Dali::Property > arg3 ;
39064   Dali::Vector2 *arg4 = 0 ;
39065   Dali::Vector2 *arg5 = 0 ;
39066   Dali::Property *argp2 ;
39067   Dali::Property *argp3 ;
39068
39069   arg1 = (Dali::PathConstrainer *)jarg1;
39070   argp2 = (Dali::Property *)jarg2;
39071   if (!argp2) {
39072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39073     return ;
39074   }
39075   arg2 = *argp2;
39076   argp3 = (Dali::Property *)jarg3;
39077   if (!argp3) {
39078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39079     return ;
39080   }
39081   arg3 = *argp3;
39082   arg4 = (Dali::Vector2 *)jarg4;
39083   if (!arg4) {
39084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39085     return ;
39086   }
39087   arg5 = (Dali::Vector2 *)jarg5;
39088   if (!arg5) {
39089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39090     return ;
39091   }
39092   {
39093     try {
39094       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39102       };
39103     } catch (...) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39106       };
39107     }
39108   }
39109 }
39110
39111
39112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39113   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39114   SwigValueWrapper< Dali::Property > arg2 ;
39115   SwigValueWrapper< Dali::Property > arg3 ;
39116   Dali::Vector2 *arg4 = 0 ;
39117   Dali::Property *argp2 ;
39118   Dali::Property *argp3 ;
39119
39120   arg1 = (Dali::PathConstrainer *)jarg1;
39121   argp2 = (Dali::Property *)jarg2;
39122   if (!argp2) {
39123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39124     return ;
39125   }
39126   arg2 = *argp2;
39127   argp3 = (Dali::Property *)jarg3;
39128   if (!argp3) {
39129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39130     return ;
39131   }
39132   arg3 = *argp3;
39133   arg4 = (Dali::Vector2 *)jarg4;
39134   if (!arg4) {
39135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39136     return ;
39137   }
39138   {
39139     try {
39140       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
39141     } catch (std::out_of_range& e) {
39142       {
39143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39144       };
39145     } catch (std::exception& e) {
39146       {
39147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39148       };
39149     } catch (...) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39152       };
39153     }
39154   }
39155 }
39156
39157
39158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
39159   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
39160   Dali::Handle *arg2 = 0 ;
39161
39162   arg1 = (Dali::PathConstrainer *)jarg1;
39163   arg2 = (Dali::Handle *)jarg2;
39164   if (!arg2) {
39165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
39166     return ;
39167   }
39168   {
39169     try {
39170       (arg1)->Remove(*arg2);
39171     } catch (std::out_of_range& e) {
39172       {
39173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39174       };
39175     } catch (std::exception& e) {
39176       {
39177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39178       };
39179     } catch (...) {
39180       {
39181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39182       };
39183     }
39184   }
39185 }
39186
39187
39188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
39189   int jresult ;
39190   Dali::FittingMode::Type result;
39191
39192   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
39193   jresult = (int)result;
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
39199   int jresult ;
39200   Dali::SamplingMode::Type result;
39201
39202   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
39203   jresult = (int)result;
39204   return jresult;
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
39209   void * jresult ;
39210   Dali::BufferImage *result = 0 ;
39211
39212   {
39213     try {
39214       result = (Dali::BufferImage *)new Dali::BufferImage();
39215     } catch (std::out_of_range& e) {
39216       {
39217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (std::exception& e) {
39220       {
39221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229   jresult = (void *)result;
39230   return jresult;
39231 }
39232
39233
39234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
39235   void * jresult ;
39236   unsigned int arg1 ;
39237   unsigned int arg2 ;
39238   Dali::Pixel::Format arg3 ;
39239   Dali::BufferImage result;
39240
39241   arg1 = (unsigned int)jarg1;
39242   arg2 = (unsigned int)jarg2;
39243   arg3 = (Dali::Pixel::Format)jarg3;
39244   {
39245     try {
39246       result = Dali::BufferImage::New(arg1,arg2,arg3);
39247     } catch (std::out_of_range& e) {
39248       {
39249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39250       };
39251     } catch (std::exception& e) {
39252       {
39253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39254       };
39255     } catch (...) {
39256       {
39257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39258       };
39259     }
39260   }
39261   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39262   return jresult;
39263 }
39264
39265
39266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
39267   void * jresult ;
39268   unsigned int arg1 ;
39269   unsigned int arg2 ;
39270   Dali::BufferImage result;
39271
39272   arg1 = (unsigned int)jarg1;
39273   arg2 = (unsigned int)jarg2;
39274   {
39275     try {
39276       result = Dali::BufferImage::New(arg1,arg2);
39277     } catch (std::out_of_range& e) {
39278       {
39279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39280       };
39281     } catch (std::exception& e) {
39282       {
39283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39284       };
39285     } catch (...) {
39286       {
39287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39288       };
39289     }
39290   }
39291   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39292   return jresult;
39293 }
39294
39295
39296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
39297   void * jresult ;
39298   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39299   unsigned int arg2 ;
39300   unsigned int arg3 ;
39301   Dali::Pixel::Format arg4 ;
39302   unsigned int arg5 ;
39303   Dali::BufferImage result;
39304
39305   arg1 = jarg1;
39306   arg2 = (unsigned int)jarg2;
39307   arg3 = (unsigned int)jarg3;
39308   arg4 = (Dali::Pixel::Format)jarg4;
39309   arg5 = (unsigned int)jarg5;
39310   {
39311     try {
39312       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
39313     } catch (std::out_of_range& e) {
39314       {
39315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39316       };
39317     } catch (std::exception& e) {
39318       {
39319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39320       };
39321     } catch (...) {
39322       {
39323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39324       };
39325     }
39326   }
39327   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39328
39329
39330   return jresult;
39331 }
39332
39333
39334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
39335   void * jresult ;
39336   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39337   unsigned int arg2 ;
39338   unsigned int arg3 ;
39339   Dali::Pixel::Format arg4 ;
39340   Dali::BufferImage result;
39341
39342   arg1 = jarg1;
39343   arg2 = (unsigned int)jarg2;
39344   arg3 = (unsigned int)jarg3;
39345   arg4 = (Dali::Pixel::Format)jarg4;
39346   {
39347     try {
39348       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39360       };
39361     }
39362   }
39363   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39364
39365
39366   return jresult;
39367 }
39368
39369
39370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
39371   void * jresult ;
39372   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
39373   unsigned int arg2 ;
39374   unsigned int arg3 ;
39375   Dali::BufferImage result;
39376
39377   arg1 = jarg1;
39378   arg2 = (unsigned int)jarg2;
39379   arg3 = (unsigned int)jarg3;
39380   {
39381     try {
39382       result = Dali::BufferImage::New(arg1,arg2,arg3);
39383     } catch (std::out_of_range& e) {
39384       {
39385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39386       };
39387     } catch (std::exception& e) {
39388       {
39389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39390       };
39391     } catch (...) {
39392       {
39393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39394       };
39395     }
39396   }
39397   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39398
39399
39400   return jresult;
39401 }
39402
39403
39404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
39405   void * jresult ;
39406   Dali::BaseHandle arg1 ;
39407   Dali::BaseHandle *argp1 ;
39408   Dali::BufferImage result;
39409
39410   argp1 = (Dali::BaseHandle *)jarg1;
39411   if (!argp1) {
39412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39413     return 0;
39414   }
39415   arg1 = *argp1;
39416   {
39417     try {
39418       result = Dali::BufferImage::DownCast(arg1);
39419     } catch (std::out_of_range& e) {
39420       {
39421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39422       };
39423     } catch (std::exception& e) {
39424       {
39425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39426       };
39427     } catch (...) {
39428       {
39429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39430       };
39431     }
39432   }
39433   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39434   return jresult;
39435 }
39436
39437
39438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
39439   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39440
39441   arg1 = (Dali::BufferImage *)jarg1;
39442   {
39443     try {
39444       delete arg1;
39445     } catch (std::out_of_range& e) {
39446       {
39447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39448       };
39449     } catch (std::exception& e) {
39450       {
39451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39452       };
39453     } catch (...) {
39454       {
39455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39456       };
39457     }
39458   }
39459 }
39460
39461
39462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
39463   void * jresult ;
39464   Dali::BufferImage *arg1 = 0 ;
39465   Dali::BufferImage *result = 0 ;
39466
39467   arg1 = (Dali::BufferImage *)jarg1;
39468   if (!arg1) {
39469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39470     return 0;
39471   }
39472   {
39473     try {
39474       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
39475     } catch (std::out_of_range& e) {
39476       {
39477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39478       };
39479     } catch (std::exception& e) {
39480       {
39481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39482       };
39483     } catch (...) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39486       };
39487     }
39488   }
39489   jresult = (void *)result;
39490   return jresult;
39491 }
39492
39493
39494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
39495   void * jresult ;
39496   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39497   Dali::BufferImage *arg2 = 0 ;
39498   Dali::BufferImage *result = 0 ;
39499
39500   arg1 = (Dali::BufferImage *)jarg1;
39501   arg2 = (Dali::BufferImage *)jarg2;
39502   if (!arg2) {
39503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
39504     return 0;
39505   }
39506   {
39507     try {
39508       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
39509     } catch (std::out_of_range& e) {
39510       {
39511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39512       };
39513     } catch (std::exception& e) {
39514       {
39515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39516       };
39517     } catch (...) {
39518       {
39519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39520       };
39521     }
39522   }
39523   jresult = (void *)result;
39524   return jresult;
39525 }
39526
39527
39528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
39529   void * jresult ;
39530   Dali::BufferImage result;
39531
39532   {
39533     try {
39534       result = Dali::BufferImage::WHITE();
39535     } catch (std::out_of_range& e) {
39536       {
39537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (std::exception& e) {
39540       {
39541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (...) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39546       };
39547     }
39548   }
39549   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
39550   return jresult;
39551 }
39552
39553
39554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
39555   void * jresult ;
39556   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39557   Dali::PixelBuffer *result = 0 ;
39558
39559   arg1 = (Dali::BufferImage *)jarg1;
39560   {
39561     try {
39562       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
39563     } catch (std::out_of_range& e) {
39564       {
39565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39566       };
39567     } catch (std::exception& e) {
39568       {
39569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39574       };
39575     }
39576   }
39577   jresult = (void *)result;
39578   return jresult;
39579 }
39580
39581
39582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
39583   unsigned int jresult ;
39584   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39585   unsigned int result;
39586
39587   arg1 = (Dali::BufferImage *)jarg1;
39588   {
39589     try {
39590       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
39591     } catch (std::out_of_range& e) {
39592       {
39593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39594       };
39595     } catch (std::exception& e) {
39596       {
39597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39598       };
39599     } catch (...) {
39600       {
39601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39602       };
39603     }
39604   }
39605   jresult = result;
39606   return jresult;
39607 }
39608
39609
39610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
39611   unsigned int jresult ;
39612   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39613   unsigned int result;
39614
39615   arg1 = (Dali::BufferImage *)jarg1;
39616   {
39617     try {
39618       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
39619     } catch (std::out_of_range& e) {
39620       {
39621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39622       };
39623     } catch (std::exception& e) {
39624       {
39625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39626       };
39627     } catch (...) {
39628       {
39629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39630       };
39631     }
39632   }
39633   jresult = result;
39634   return jresult;
39635 }
39636
39637
39638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
39639   int jresult ;
39640   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39641   Dali::Pixel::Format result;
39642
39643   arg1 = (Dali::BufferImage *)jarg1;
39644   {
39645     try {
39646       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
39647     } catch (std::out_of_range& e) {
39648       {
39649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39650       };
39651     } catch (std::exception& e) {
39652       {
39653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39654       };
39655     } catch (...) {
39656       {
39657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39658       };
39659     }
39660   }
39661   jresult = (int)result;
39662   return jresult;
39663 }
39664
39665
39666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
39667   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39668
39669   arg1 = (Dali::BufferImage *)jarg1;
39670   {
39671     try {
39672       (arg1)->Update();
39673     } catch (std::out_of_range& e) {
39674       {
39675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39676       };
39677     } catch (std::exception& e) {
39678       {
39679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39680       };
39681     } catch (...) {
39682       {
39683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39684       };
39685     }
39686   }
39687 }
39688
39689
39690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
39691   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39692   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
39693   Dali::RectArea *argp2 ;
39694
39695   arg1 = (Dali::BufferImage *)jarg1;
39696   argp2 = (Dali::RectArea *)jarg2;
39697   if (!argp2) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
39699     return ;
39700   }
39701   arg2 = *argp2;
39702   {
39703     try {
39704       (arg1)->Update(arg2);
39705     } catch (std::out_of_range& e) {
39706       {
39707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39708       };
39709     } catch (std::exception& e) {
39710       {
39711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39712       };
39713     } catch (...) {
39714       {
39715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39716       };
39717     }
39718   }
39719 }
39720
39721
39722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
39723   unsigned int jresult ;
39724   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
39725   bool result;
39726
39727   arg1 = (Dali::BufferImage *)jarg1;
39728   {
39729     try {
39730       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
39731     } catch (std::out_of_range& e) {
39732       {
39733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39734       };
39735     } catch (std::exception& e) {
39736       {
39737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39738       };
39739     } catch (...) {
39740       {
39741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39742       };
39743     }
39744   }
39745   jresult = result;
39746   return jresult;
39747 }
39748
39749
39750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
39751   void * jresult ;
39752   Dali::EncodedBufferImage *result = 0 ;
39753
39754   {
39755     try {
39756       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (...) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39768       };
39769     }
39770   }
39771   jresult = (void *)result;
39772   return jresult;
39773 }
39774
39775
39776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
39777   void * jresult ;
39778   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39779   std::size_t arg2 ;
39780   Dali::EncodedBufferImage result;
39781
39782   arg1 = (uint8_t *)jarg1;
39783   arg2 = (std::size_t)jarg2;
39784   {
39785     try {
39786       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
39787     } catch (std::out_of_range& e) {
39788       {
39789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39790       };
39791     } catch (std::exception& e) {
39792       {
39793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39794       };
39795     } catch (...) {
39796       {
39797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39798       };
39799     }
39800   }
39801   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
39807   void * jresult ;
39808   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39809   std::size_t arg2 ;
39810   Dali::ImageDimensions arg3 ;
39811   Dali::FittingMode::Type arg4 ;
39812   Dali::SamplingMode::Type arg5 ;
39813   bool arg6 ;
39814   Dali::ImageDimensions *argp3 ;
39815   Dali::EncodedBufferImage result;
39816
39817   arg1 = (uint8_t *)jarg1;
39818   arg2 = (std::size_t)jarg2;
39819   argp3 = (Dali::ImageDimensions *)jarg3;
39820   if (!argp3) {
39821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39822     return 0;
39823   }
39824   arg3 = *argp3;
39825   arg4 = (Dali::FittingMode::Type)jarg4;
39826   arg5 = (Dali::SamplingMode::Type)jarg5;
39827   arg6 = jarg6 ? true : false;
39828   {
39829     try {
39830       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
39831     } catch (std::out_of_range& e) {
39832       {
39833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (std::exception& e) {
39836       {
39837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39838       };
39839     } catch (...) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39842       };
39843     }
39844   }
39845   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
39851   void * jresult ;
39852   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
39853   std::size_t arg2 ;
39854   Dali::ImageDimensions arg3 ;
39855   Dali::FittingMode::Type arg4 ;
39856   Dali::SamplingMode::Type arg5 ;
39857   Dali::ImageDimensions *argp3 ;
39858   Dali::EncodedBufferImage result;
39859
39860   arg1 = (uint8_t *)jarg1;
39861   arg2 = (std::size_t)jarg2;
39862   argp3 = (Dali::ImageDimensions *)jarg3;
39863   if (!argp3) {
39864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39865     return 0;
39866   }
39867   arg3 = *argp3;
39868   arg4 = (Dali::FittingMode::Type)jarg4;
39869   arg5 = (Dali::SamplingMode::Type)jarg5;
39870   {
39871     try {
39872       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
39873     } catch (std::out_of_range& e) {
39874       {
39875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39876       };
39877     } catch (std::exception& e) {
39878       {
39879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39880       };
39881     } catch (...) {
39882       {
39883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39884       };
39885     }
39886   }
39887   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39888   return jresult;
39889 }
39890
39891
39892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
39893   void * jresult ;
39894   Dali::BaseHandle arg1 ;
39895   Dali::BaseHandle *argp1 ;
39896   Dali::EncodedBufferImage result;
39897
39898   argp1 = (Dali::BaseHandle *)jarg1;
39899   if (!argp1) {
39900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39901     return 0;
39902   }
39903   arg1 = *argp1;
39904   {
39905     try {
39906       result = Dali::EncodedBufferImage::DownCast(arg1);
39907     } catch (std::out_of_range& e) {
39908       {
39909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39910       };
39911     } catch (std::exception& e) {
39912       {
39913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39914       };
39915     } catch (...) {
39916       {
39917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39918       };
39919     }
39920   }
39921   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
39922   return jresult;
39923 }
39924
39925
39926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
39927   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39928
39929   arg1 = (Dali::EncodedBufferImage *)jarg1;
39930   {
39931     try {
39932       delete arg1;
39933     } catch (std::out_of_range& e) {
39934       {
39935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39936       };
39937     } catch (std::exception& e) {
39938       {
39939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39940       };
39941     } catch (...) {
39942       {
39943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39944       };
39945     }
39946   }
39947 }
39948
39949
39950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
39951   void * jresult ;
39952   Dali::EncodedBufferImage *arg1 = 0 ;
39953   Dali::EncodedBufferImage *result = 0 ;
39954
39955   arg1 = (Dali::EncodedBufferImage *)jarg1;
39956   if (!arg1) {
39957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39958     return 0;
39959   }
39960   {
39961     try {
39962       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
39963     } catch (std::out_of_range& e) {
39964       {
39965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39966       };
39967     } catch (std::exception& e) {
39968       {
39969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39970       };
39971     } catch (...) {
39972       {
39973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39974       };
39975     }
39976   }
39977   jresult = (void *)result;
39978   return jresult;
39979 }
39980
39981
39982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
39983   void * jresult ;
39984   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
39985   Dali::EncodedBufferImage *arg2 = 0 ;
39986   Dali::EncodedBufferImage *result = 0 ;
39987
39988   arg1 = (Dali::EncodedBufferImage *)jarg1;
39989   arg2 = (Dali::EncodedBufferImage *)jarg2;
39990   if (!arg2) {
39991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
39992     return 0;
39993   }
39994   {
39995     try {
39996       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
39997     } catch (std::out_of_range& e) {
39998       {
39999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (std::exception& e) {
40002       {
40003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40008       };
40009     }
40010   }
40011   jresult = (void *)result;
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
40017   void * jresult ;
40018   Dali::NativeImage *result = 0 ;
40019
40020   {
40021     try {
40022       result = (Dali::NativeImage *)new Dali::NativeImage();
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (...) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40034       };
40035     }
40036   }
40037   jresult = (void *)result;
40038   return jresult;
40039 }
40040
40041
40042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
40043   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40044
40045   arg1 = (Dali::NativeImage *)jarg1;
40046   {
40047     try {
40048       delete arg1;
40049     } catch (std::out_of_range& e) {
40050       {
40051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40052       };
40053     } catch (std::exception& e) {
40054       {
40055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40056       };
40057     } catch (...) {
40058       {
40059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40060       };
40061     }
40062   }
40063 }
40064
40065
40066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
40067   void * jresult ;
40068   Dali::NativeImage *arg1 = 0 ;
40069   Dali::NativeImage *result = 0 ;
40070
40071   arg1 = (Dali::NativeImage *)jarg1;
40072   if (!arg1) {
40073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40074     return 0;
40075   }
40076   {
40077     try {
40078       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
40079     } catch (std::out_of_range& e) {
40080       {
40081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40082       };
40083     } catch (std::exception& e) {
40084       {
40085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40086       };
40087     } catch (...) {
40088       {
40089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40090       };
40091     }
40092   }
40093   jresult = (void *)result;
40094   return jresult;
40095 }
40096
40097
40098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
40099   void * jresult ;
40100   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40101   Dali::NativeImage *arg2 = 0 ;
40102   Dali::NativeImage *result = 0 ;
40103
40104   arg1 = (Dali::NativeImage *)jarg1;
40105   arg2 = (Dali::NativeImage *)jarg2;
40106   if (!arg2) {
40107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
40108     return 0;
40109   }
40110   {
40111     try {
40112       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
40113     } catch (std::out_of_range& e) {
40114       {
40115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40116       };
40117     } catch (std::exception& e) {
40118       {
40119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40120       };
40121     } catch (...) {
40122       {
40123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40124       };
40125     }
40126   }
40127   jresult = (void *)result;
40128   return jresult;
40129 }
40130
40131
40132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
40133   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40134
40135   arg1 = (Dali::NativeImage *)jarg1;
40136   {
40137     try {
40138       (arg1)->CreateGlTexture();
40139     } catch (std::out_of_range& e) {
40140       {
40141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40142       };
40143     } catch (std::exception& e) {
40144       {
40145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40146       };
40147     } catch (...) {
40148       {
40149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40150       };
40151     }
40152   }
40153 }
40154
40155
40156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
40157   void * jresult ;
40158   NativeImageInterface *arg1 = 0 ;
40159   Dali::NativeImage result;
40160
40161   arg1 = (NativeImageInterface *)jarg1;
40162   if (!arg1) {
40163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
40164     return 0;
40165   }
40166   {
40167     try {
40168       result = Dali::NativeImage::New(*arg1);
40169     } catch (std::out_of_range& e) {
40170       {
40171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40172       };
40173     } catch (std::exception& e) {
40174       {
40175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (...) {
40178       {
40179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40180       };
40181     }
40182   }
40183   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40184   return jresult;
40185 }
40186
40187
40188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
40189   void * jresult ;
40190   Dali::BaseHandle arg1 ;
40191   Dali::BaseHandle *argp1 ;
40192   Dali::NativeImage result;
40193
40194   argp1 = (Dali::BaseHandle *)jarg1;
40195   if (!argp1) {
40196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40197     return 0;
40198   }
40199   arg1 = *argp1;
40200   {
40201     try {
40202       result = Dali::NativeImage::DownCast(arg1);
40203     } catch (std::out_of_range& e) {
40204       {
40205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40206       };
40207     } catch (std::exception& e) {
40208       {
40209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40210       };
40211     } catch (...) {
40212       {
40213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40214       };
40215     }
40216   }
40217   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
40218   return jresult;
40219 }
40220
40221
40222 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
40223   char * jresult ;
40224   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40225   char *result = 0 ;
40226
40227   arg1 = (Dali::NativeImage *)jarg1;
40228   {
40229     try {
40230       result = (char *)(arg1)->GetCustomFragmentPreFix();
40231     } catch (std::out_of_range& e) {
40232       {
40233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40234       };
40235     } catch (std::exception& e) {
40236       {
40237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40238       };
40239     } catch (...) {
40240       {
40241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40242       };
40243     }
40244   }
40245   jresult = SWIG_csharp_string_callback((const char *)result);
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
40251   char * jresult ;
40252   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
40253   char *result = 0 ;
40254
40255   arg1 = (Dali::NativeImage *)jarg1;
40256   {
40257     try {
40258       result = (char *)(arg1)->GetCustomSamplerTypename();
40259     } catch (std::out_of_range& e) {
40260       {
40261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40262       };
40263     } catch (std::exception& e) {
40264       {
40265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40266       };
40267     } catch (...) {
40268       {
40269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40270       };
40271     }
40272   }
40273   jresult = SWIG_csharp_string_callback((const char *)result);
40274   return jresult;
40275 }
40276
40277
40278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
40279   unsigned int jresult ;
40280   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40281   bool result;
40282
40283   arg1 = (Dali::NativeImageInterface *)jarg1;
40284   {
40285     try {
40286       result = (bool)(arg1)->GlExtensionCreate();
40287     } catch (std::out_of_range& e) {
40288       {
40289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40290       };
40291     } catch (std::exception& e) {
40292       {
40293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (...) {
40296       {
40297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40298       };
40299     }
40300   }
40301   jresult = result;
40302   return jresult;
40303 }
40304
40305
40306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
40307   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40308
40309   arg1 = (Dali::NativeImageInterface *)jarg1;
40310   {
40311     try {
40312       (arg1)->GlExtensionDestroy();
40313     } catch (std::out_of_range& e) {
40314       {
40315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40316       };
40317     } catch (std::exception& e) {
40318       {
40319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40320       };
40321     } catch (...) {
40322       {
40323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40324       };
40325     }
40326   }
40327 }
40328
40329
40330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
40331   unsigned int jresult ;
40332   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40333   unsigned int result;
40334
40335   arg1 = (Dali::NativeImageInterface *)jarg1;
40336   {
40337     try {
40338       result = (unsigned int)(arg1)->TargetTexture();
40339     } catch (std::out_of_range& e) {
40340       {
40341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40342       };
40343     } catch (std::exception& e) {
40344       {
40345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40346       };
40347     } catch (...) {
40348       {
40349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40350       };
40351     }
40352   }
40353   jresult = result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
40359   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40360
40361   arg1 = (Dali::NativeImageInterface *)jarg1;
40362   {
40363     try {
40364       (arg1)->PrepareTexture();
40365     } catch (std::out_of_range& e) {
40366       {
40367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40368       };
40369     } catch (std::exception& e) {
40370       {
40371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40372       };
40373     } catch (...) {
40374       {
40375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40376       };
40377     }
40378   }
40379 }
40380
40381
40382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
40383   unsigned int jresult ;
40384   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40385   unsigned int result;
40386
40387   arg1 = (Dali::NativeImageInterface *)jarg1;
40388   {
40389     try {
40390       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
40391     } catch (std::out_of_range& e) {
40392       {
40393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40394       };
40395     } catch (std::exception& e) {
40396       {
40397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40398       };
40399     } catch (...) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40402       };
40403     }
40404   }
40405   jresult = result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
40411   unsigned int jresult ;
40412   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40413   unsigned int result;
40414
40415   arg1 = (Dali::NativeImageInterface *)jarg1;
40416   {
40417     try {
40418       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
40419     } catch (std::out_of_range& e) {
40420       {
40421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40422       };
40423     } catch (std::exception& e) {
40424       {
40425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40426       };
40427     } catch (...) {
40428       {
40429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40430       };
40431     }
40432   }
40433   jresult = result;
40434   return jresult;
40435 }
40436
40437
40438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
40439   unsigned int jresult ;
40440   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
40441   bool result;
40442
40443   arg1 = (Dali::NativeImageInterface *)jarg1;
40444   {
40445     try {
40446       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
40447     } catch (std::out_of_range& e) {
40448       {
40449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40450       };
40451     } catch (std::exception& e) {
40452       {
40453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40454       };
40455     } catch (...) {
40456       {
40457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40458       };
40459     }
40460   }
40461   jresult = result;
40462   return jresult;
40463 }
40464
40465
40466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
40467   void * jresult ;
40468   std::string *arg1 = 0 ;
40469   Dali::ImageDimensions result;
40470
40471   if (!jarg1) {
40472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40473     return 0;
40474   }
40475   std::string arg1_str(jarg1);
40476   arg1 = &arg1_str;
40477   {
40478     try {
40479       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
40480     } catch (std::out_of_range& e) {
40481       {
40482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40483       };
40484     } catch (std::exception& e) {
40485       {
40486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40487       };
40488     } catch (...) {
40489       {
40490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40491       };
40492     }
40493   }
40494   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
40495
40496   //argout typemap for const std::string&
40497
40498   return jresult;
40499 }
40500
40501
40502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
40503   void * jresult ;
40504   Dali::ResourceImage *result = 0 ;
40505
40506   {
40507     try {
40508       result = (Dali::ResourceImage *)new Dali::ResourceImage();
40509     } catch (std::out_of_range& e) {
40510       {
40511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40512       };
40513     } catch (std::exception& e) {
40514       {
40515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40516       };
40517     } catch (...) {
40518       {
40519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40520       };
40521     }
40522   }
40523   jresult = (void *)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
40529   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40530
40531   arg1 = (Dali::ResourceImage *)jarg1;
40532   {
40533     try {
40534       delete arg1;
40535     } catch (std::out_of_range& e) {
40536       {
40537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40538       };
40539     } catch (std::exception& e) {
40540       {
40541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40542       };
40543     } catch (...) {
40544       {
40545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40546       };
40547     }
40548   }
40549 }
40550
40551
40552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
40553   void * jresult ;
40554   Dali::ResourceImage *arg1 = 0 ;
40555   Dali::ResourceImage *result = 0 ;
40556
40557   arg1 = (Dali::ResourceImage *)jarg1;
40558   if (!arg1) {
40559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40560     return 0;
40561   }
40562   {
40563     try {
40564       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40572       };
40573     } catch (...) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40576       };
40577     }
40578   }
40579   jresult = (void *)result;
40580   return jresult;
40581 }
40582
40583
40584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
40585   void * jresult ;
40586   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40587   Dali::ResourceImage *arg2 = 0 ;
40588   Dali::ResourceImage *result = 0 ;
40589
40590   arg1 = (Dali::ResourceImage *)jarg1;
40591   arg2 = (Dali::ResourceImage *)jarg2;
40592   if (!arg2) {
40593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
40594     return 0;
40595   }
40596   {
40597     try {
40598       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
40599     } catch (std::out_of_range& e) {
40600       {
40601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40602       };
40603     } catch (std::exception& e) {
40604       {
40605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40606       };
40607     } catch (...) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40610       };
40611     }
40612   }
40613   jresult = (void *)result;
40614   return jresult;
40615 }
40616
40617
40618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
40619   void * jresult ;
40620   std::string *arg1 = 0 ;
40621   bool arg2 ;
40622   Dali::ResourceImage result;
40623
40624   if (!jarg1) {
40625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40626     return 0;
40627   }
40628   std::string arg1_str(jarg1);
40629   arg1 = &arg1_str;
40630   arg2 = jarg2 ? true : false;
40631   {
40632     try {
40633       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40634     } catch (std::out_of_range& e) {
40635       {
40636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40637       };
40638     } catch (std::exception& e) {
40639       {
40640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40641       };
40642     } catch (...) {
40643       {
40644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40645       };
40646     }
40647   }
40648   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40649
40650   //argout typemap for const std::string&
40651
40652   return jresult;
40653 }
40654
40655
40656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
40657   void * jresult ;
40658   std::string *arg1 = 0 ;
40659   Dali::ResourceImage result;
40660
40661   if (!jarg1) {
40662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40663     return 0;
40664   }
40665   std::string arg1_str(jarg1);
40666   arg1 = &arg1_str;
40667   {
40668     try {
40669       result = Dali::ResourceImage::New((std::string const &)*arg1);
40670     } catch (std::out_of_range& e) {
40671       {
40672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40673       };
40674     } catch (std::exception& e) {
40675       {
40676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40677       };
40678     } catch (...) {
40679       {
40680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40681       };
40682     }
40683   }
40684   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40685
40686   //argout typemap for const std::string&
40687
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
40693   void * jresult ;
40694   std::string *arg1 = 0 ;
40695   Dali::ImageDimensions arg2 ;
40696   Dali::FittingMode::Type arg3 ;
40697   Dali::SamplingMode::Type arg4 ;
40698   bool arg5 ;
40699   Dali::ImageDimensions *argp2 ;
40700   Dali::ResourceImage result;
40701
40702   if (!jarg1) {
40703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40704     return 0;
40705   }
40706   std::string arg1_str(jarg1);
40707   arg1 = &arg1_str;
40708   argp2 = (Dali::ImageDimensions *)jarg2;
40709   if (!argp2) {
40710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40711     return 0;
40712   }
40713   arg2 = *argp2;
40714   arg3 = (Dali::FittingMode::Type)jarg3;
40715   arg4 = (Dali::SamplingMode::Type)jarg4;
40716   arg5 = jarg5 ? true : false;
40717   {
40718     try {
40719       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
40720     } catch (std::out_of_range& e) {
40721       {
40722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40723       };
40724     } catch (std::exception& e) {
40725       {
40726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40727       };
40728     } catch (...) {
40729       {
40730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40731       };
40732     }
40733   }
40734   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40735
40736   //argout typemap for const std::string&
40737
40738   return jresult;
40739 }
40740
40741
40742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
40743   void * jresult ;
40744   std::string *arg1 = 0 ;
40745   Dali::ImageDimensions arg2 ;
40746   Dali::FittingMode::Type arg3 ;
40747   Dali::SamplingMode::Type arg4 ;
40748   Dali::ImageDimensions *argp2 ;
40749   Dali::ResourceImage result;
40750
40751   if (!jarg1) {
40752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40753     return 0;
40754   }
40755   std::string arg1_str(jarg1);
40756   arg1 = &arg1_str;
40757   argp2 = (Dali::ImageDimensions *)jarg2;
40758   if (!argp2) {
40759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40760     return 0;
40761   }
40762   arg2 = *argp2;
40763   arg3 = (Dali::FittingMode::Type)jarg3;
40764   arg4 = (Dali::SamplingMode::Type)jarg4;
40765   {
40766     try {
40767       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
40768     } catch (std::out_of_range& e) {
40769       {
40770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40771       };
40772     } catch (std::exception& e) {
40773       {
40774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40775       };
40776     } catch (...) {
40777       {
40778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40779       };
40780     }
40781   }
40782   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40783
40784   //argout typemap for const std::string&
40785
40786   return jresult;
40787 }
40788
40789
40790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
40791   void * jresult ;
40792   std::string *arg1 = 0 ;
40793   Dali::ImageDimensions arg2 ;
40794   Dali::FittingMode::Type arg3 ;
40795   Dali::ImageDimensions *argp2 ;
40796   Dali::ResourceImage result;
40797
40798   if (!jarg1) {
40799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40800     return 0;
40801   }
40802   std::string arg1_str(jarg1);
40803   arg1 = &arg1_str;
40804   argp2 = (Dali::ImageDimensions *)jarg2;
40805   if (!argp2) {
40806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40807     return 0;
40808   }
40809   arg2 = *argp2;
40810   arg3 = (Dali::FittingMode::Type)jarg3;
40811   {
40812     try {
40813       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
40814     } catch (std::out_of_range& e) {
40815       {
40816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40817       };
40818     } catch (std::exception& e) {
40819       {
40820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40821       };
40822     } catch (...) {
40823       {
40824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40825       };
40826     }
40827   }
40828   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40829
40830   //argout typemap for const std::string&
40831
40832   return jresult;
40833 }
40834
40835
40836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
40837   void * jresult ;
40838   std::string *arg1 = 0 ;
40839   Dali::ImageDimensions arg2 ;
40840   Dali::ImageDimensions *argp2 ;
40841   Dali::ResourceImage result;
40842
40843   if (!jarg1) {
40844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40845     return 0;
40846   }
40847   std::string arg1_str(jarg1);
40848   arg1 = &arg1_str;
40849   argp2 = (Dali::ImageDimensions *)jarg2;
40850   if (!argp2) {
40851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40852     return 0;
40853   }
40854   arg2 = *argp2;
40855   {
40856     try {
40857       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
40858     } catch (std::out_of_range& e) {
40859       {
40860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40861       };
40862     } catch (std::exception& e) {
40863       {
40864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40865       };
40866     } catch (...) {
40867       {
40868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40869       };
40870     }
40871   }
40872   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40873
40874   //argout typemap for const std::string&
40875
40876   return jresult;
40877 }
40878
40879
40880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
40881   void * jresult ;
40882   Dali::BaseHandle arg1 ;
40883   Dali::BaseHandle *argp1 ;
40884   Dali::ResourceImage result;
40885
40886   argp1 = (Dali::BaseHandle *)jarg1;
40887   if (!argp1) {
40888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40889     return 0;
40890   }
40891   arg1 = *argp1;
40892   {
40893     try {
40894       result = Dali::ResourceImage::DownCast(arg1);
40895     } catch (std::out_of_range& e) {
40896       {
40897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40898       };
40899     } catch (std::exception& e) {
40900       {
40901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40902       };
40903     } catch (...) {
40904       {
40905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40906       };
40907     }
40908   }
40909   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
40910   return jresult;
40911 }
40912
40913
40914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
40915   int jresult ;
40916   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40917   Dali::LoadingState result;
40918
40919   arg1 = (Dali::ResourceImage *)jarg1;
40920   {
40921     try {
40922       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
40923     } catch (std::out_of_range& e) {
40924       {
40925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40926       };
40927     } catch (std::exception& e) {
40928       {
40929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40930       };
40931     } catch (...) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40934       };
40935     }
40936   }
40937   jresult = (int)result;
40938   return jresult;
40939 }
40940
40941
40942 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
40943   char * jresult ;
40944   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40945   std::string result;
40946
40947   arg1 = (Dali::ResourceImage *)jarg1;
40948   {
40949     try {
40950       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
40951     } catch (std::out_of_range& e) {
40952       {
40953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40954       };
40955     } catch (std::exception& e) {
40956       {
40957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40958       };
40959     } catch (...) {
40960       {
40961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40962       };
40963     }
40964   }
40965   jresult = SWIG_csharp_string_callback((&result)->c_str());
40966   return jresult;
40967 }
40968
40969
40970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
40971   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40972
40973   arg1 = (Dali::ResourceImage *)jarg1;
40974   {
40975     try {
40976       (arg1)->Reload();
40977     } catch (std::out_of_range& e) {
40978       {
40979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40980       };
40981     } catch (std::exception& e) {
40982       {
40983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40984       };
40985     } catch (...) {
40986       {
40987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40988       };
40989     }
40990   }
40991 }
40992
40993
40994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
40995   void * jresult ;
40996   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
40997   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
40998
40999   arg1 = (Dali::ResourceImage *)jarg1;
41000   {
41001     try {
41002       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
41003     } catch (std::out_of_range& e) {
41004       {
41005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41006       };
41007     } catch (std::exception& e) {
41008       {
41009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41010       };
41011     } catch (...) {
41012       {
41013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41014       };
41015     }
41016   }
41017   jresult = (void *)result;
41018   return jresult;
41019 }
41020
41021
41022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
41023   void * jresult ;
41024   Dali::FrameBufferImage *result = 0 ;
41025
41026   {
41027     try {
41028       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
41029     } catch (std::out_of_range& e) {
41030       {
41031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41032       };
41033     } catch (std::exception& e) {
41034       {
41035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41036       };
41037     } catch (...) {
41038       {
41039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41040       };
41041     }
41042   }
41043   jresult = (void *)result;
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
41049   void * jresult ;
41050   unsigned int arg1 ;
41051   unsigned int arg2 ;
41052   Dali::Pixel::Format arg3 ;
41053   Dali::RenderBuffer::Format arg4 ;
41054   Dali::FrameBufferImage result;
41055
41056   arg1 = (unsigned int)jarg1;
41057   arg2 = (unsigned int)jarg2;
41058   arg3 = (Dali::Pixel::Format)jarg3;
41059   arg4 = (Dali::RenderBuffer::Format)jarg4;
41060   {
41061     try {
41062       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (...) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41074       };
41075     }
41076   }
41077   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41078   return jresult;
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41083   void * jresult ;
41084   unsigned int arg1 ;
41085   unsigned int arg2 ;
41086   Dali::Pixel::Format arg3 ;
41087   Dali::FrameBufferImage result;
41088
41089   arg1 = (unsigned int)jarg1;
41090   arg2 = (unsigned int)jarg2;
41091   arg3 = (Dali::Pixel::Format)jarg3;
41092   {
41093     try {
41094       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
41095     } catch (std::out_of_range& e) {
41096       {
41097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41098       };
41099     } catch (std::exception& e) {
41100       {
41101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41102       };
41103     } catch (...) {
41104       {
41105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41106       };
41107     }
41108   }
41109   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
41115   void * jresult ;
41116   unsigned int arg1 ;
41117   unsigned int arg2 ;
41118   Dali::FrameBufferImage result;
41119
41120   arg1 = (unsigned int)jarg1;
41121   arg2 = (unsigned int)jarg2;
41122   {
41123     try {
41124       result = Dali::FrameBufferImage::New(arg1,arg2);
41125     } catch (std::out_of_range& e) {
41126       {
41127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (std::exception& e) {
41130       {
41131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41132       };
41133     } catch (...) {
41134       {
41135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41136       };
41137     }
41138   }
41139   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41140   return jresult;
41141 }
41142
41143
41144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
41145   void * jresult ;
41146   unsigned int arg1 ;
41147   Dali::FrameBufferImage result;
41148
41149   arg1 = (unsigned int)jarg1;
41150   {
41151     try {
41152       result = Dali::FrameBufferImage::New(arg1);
41153     } catch (std::out_of_range& e) {
41154       {
41155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41156       };
41157     } catch (std::exception& e) {
41158       {
41159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (...) {
41162       {
41163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41164       };
41165     }
41166   }
41167   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41168   return jresult;
41169 }
41170
41171
41172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
41173   void * jresult ;
41174   Dali::FrameBufferImage result;
41175
41176   {
41177     try {
41178       result = Dali::FrameBufferImage::New();
41179     } catch (std::out_of_range& e) {
41180       {
41181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41182       };
41183     } catch (std::exception& e) {
41184       {
41185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41186       };
41187     } catch (...) {
41188       {
41189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41190       };
41191     }
41192   }
41193   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41194   return jresult;
41195 }
41196
41197
41198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
41199   void * jresult ;
41200   Dali::NativeImageInterface *arg1 = 0 ;
41201   Dali::FrameBufferImage result;
41202
41203   arg1 = (Dali::NativeImageInterface *)jarg1;
41204   if (!arg1) {
41205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
41206     return 0;
41207   }
41208   {
41209     try {
41210       result = Dali::FrameBufferImage::New(*arg1);
41211     } catch (std::out_of_range& e) {
41212       {
41213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41214       };
41215     } catch (std::exception& e) {
41216       {
41217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41218       };
41219     } catch (...) {
41220       {
41221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41222       };
41223     }
41224   }
41225   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41226   return jresult;
41227 }
41228
41229
41230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
41231   void * jresult ;
41232   Dali::BaseHandle arg1 ;
41233   Dali::BaseHandle *argp1 ;
41234   Dali::FrameBufferImage result;
41235
41236   argp1 = (Dali::BaseHandle *)jarg1;
41237   if (!argp1) {
41238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41239     return 0;
41240   }
41241   arg1 = *argp1;
41242   {
41243     try {
41244       result = Dali::FrameBufferImage::DownCast(arg1);
41245     } catch (std::out_of_range& e) {
41246       {
41247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41248       };
41249     } catch (std::exception& e) {
41250       {
41251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (...) {
41254       {
41255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41256       };
41257     }
41258   }
41259   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
41260   return jresult;
41261 }
41262
41263
41264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
41265   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41266
41267   arg1 = (Dali::FrameBufferImage *)jarg1;
41268   {
41269     try {
41270       delete arg1;
41271     } catch (std::out_of_range& e) {
41272       {
41273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41274       };
41275     } catch (std::exception& e) {
41276       {
41277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41278       };
41279     } catch (...) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41282       };
41283     }
41284   }
41285 }
41286
41287
41288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
41289   void * jresult ;
41290   Dali::FrameBufferImage *arg1 = 0 ;
41291   Dali::FrameBufferImage *result = 0 ;
41292
41293   arg1 = (Dali::FrameBufferImage *)jarg1;
41294   if (!arg1) {
41295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41296     return 0;
41297   }
41298   {
41299     try {
41300       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
41301     } catch (std::out_of_range& e) {
41302       {
41303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41304       };
41305     } catch (std::exception& e) {
41306       {
41307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41308       };
41309     } catch (...) {
41310       {
41311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41312       };
41313     }
41314   }
41315   jresult = (void *)result;
41316   return jresult;
41317 }
41318
41319
41320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
41321   void * jresult ;
41322   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
41323   Dali::FrameBufferImage *arg2 = 0 ;
41324   Dali::FrameBufferImage *result = 0 ;
41325
41326   arg1 = (Dali::FrameBufferImage *)jarg1;
41327   arg2 = (Dali::FrameBufferImage *)jarg2;
41328   if (!arg2) {
41329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
41330     return 0;
41331   }
41332   {
41333     try {
41334       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
41335     } catch (std::out_of_range& e) {
41336       {
41337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41338       };
41339     } catch (std::exception& e) {
41340       {
41341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (...) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41346       };
41347     }
41348   }
41349   jresult = (void *)result;
41350   return jresult;
41351 }
41352
41353
41354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
41355   void * jresult ;
41356   Dali::NinePatchImage *result = 0 ;
41357
41358   {
41359     try {
41360       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
41361     } catch (std::out_of_range& e) {
41362       {
41363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41364       };
41365     } catch (std::exception& e) {
41366       {
41367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41368       };
41369     } catch (...) {
41370       {
41371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41372       };
41373     }
41374   }
41375   jresult = (void *)result;
41376   return jresult;
41377 }
41378
41379
41380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
41381   void * jresult ;
41382   std::string *arg1 = 0 ;
41383   Dali::NinePatchImage result;
41384
41385   if (!jarg1) {
41386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41387     return 0;
41388   }
41389   std::string arg1_str(jarg1);
41390   arg1 = &arg1_str;
41391   {
41392     try {
41393       result = Dali::NinePatchImage::New((std::string const &)*arg1);
41394     } catch (std::out_of_range& e) {
41395       {
41396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41397       };
41398     } catch (std::exception& e) {
41399       {
41400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41401       };
41402     } catch (...) {
41403       {
41404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41405       };
41406     }
41407   }
41408   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41409
41410   //argout typemap for const std::string&
41411
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
41417   void * jresult ;
41418   Dali::BaseHandle arg1 ;
41419   Dali::BaseHandle *argp1 ;
41420   Dali::NinePatchImage result;
41421
41422   argp1 = (Dali::BaseHandle *)jarg1;
41423   if (!argp1) {
41424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41425     return 0;
41426   }
41427   arg1 = *argp1;
41428   {
41429     try {
41430       result = Dali::NinePatchImage::DownCast(arg1);
41431     } catch (std::out_of_range& e) {
41432       {
41433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41434       };
41435     } catch (std::exception& e) {
41436       {
41437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41438       };
41439     } catch (...) {
41440       {
41441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41442       };
41443     }
41444   }
41445   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
41446   return jresult;
41447 }
41448
41449
41450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
41451   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41452
41453   arg1 = (Dali::NinePatchImage *)jarg1;
41454   {
41455     try {
41456       delete arg1;
41457     } catch (std::out_of_range& e) {
41458       {
41459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41460       };
41461     } catch (std::exception& e) {
41462       {
41463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41464       };
41465     } catch (...) {
41466       {
41467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41468       };
41469     }
41470   }
41471 }
41472
41473
41474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
41475   void * jresult ;
41476   Dali::NinePatchImage *arg1 = 0 ;
41477   Dali::NinePatchImage *result = 0 ;
41478
41479   arg1 = (Dali::NinePatchImage *)jarg1;
41480   if (!arg1) {
41481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41482     return 0;
41483   }
41484   {
41485     try {
41486       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
41487     } catch (std::out_of_range& e) {
41488       {
41489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41490       };
41491     } catch (std::exception& e) {
41492       {
41493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41494       };
41495     } catch (...) {
41496       {
41497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41498       };
41499     }
41500   }
41501   jresult = (void *)result;
41502   return jresult;
41503 }
41504
41505
41506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
41507   void * jresult ;
41508   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41509   Dali::NinePatchImage *arg2 = 0 ;
41510   Dali::NinePatchImage *result = 0 ;
41511
41512   arg1 = (Dali::NinePatchImage *)jarg1;
41513   arg2 = (Dali::NinePatchImage *)jarg2;
41514   if (!arg2) {
41515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
41516     return 0;
41517   }
41518   {
41519     try {
41520       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
41521     } catch (std::out_of_range& e) {
41522       {
41523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41524       };
41525     } catch (std::exception& e) {
41526       {
41527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41528       };
41529     } catch (...) {
41530       {
41531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41532       };
41533     }
41534   }
41535   jresult = (void *)result;
41536   return jresult;
41537 }
41538
41539
41540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
41541   void * jresult ;
41542   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41543   Dali::Vector4 result;
41544
41545   arg1 = (Dali::NinePatchImage *)jarg1;
41546   {
41547     try {
41548       result = (arg1)->GetStretchBorders();
41549     } catch (std::out_of_range& e) {
41550       {
41551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41552       };
41553     } catch (std::exception& e) {
41554       {
41555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41556       };
41557     } catch (...) {
41558       {
41559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41560       };
41561     }
41562   }
41563   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41564   return jresult;
41565 }
41566
41567
41568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
41569   void * jresult ;
41570   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41571   Dali::NinePatchImage::StretchRanges *result = 0 ;
41572
41573   arg1 = (Dali::NinePatchImage *)jarg1;
41574   {
41575     try {
41576       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
41577     } catch (std::out_of_range& e) {
41578       {
41579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41580       };
41581     } catch (std::exception& e) {
41582       {
41583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41584       };
41585     } catch (...) {
41586       {
41587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41588       };
41589     }
41590   }
41591   jresult = (void *)result;
41592   return jresult;
41593 }
41594
41595
41596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
41597   void * jresult ;
41598   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41599   Dali::NinePatchImage::StretchRanges *result = 0 ;
41600
41601   arg1 = (Dali::NinePatchImage *)jarg1;
41602   {
41603     try {
41604       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
41605     } catch (std::out_of_range& e) {
41606       {
41607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (std::exception& e) {
41610       {
41611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41612       };
41613     } catch (...) {
41614       {
41615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41616       };
41617     }
41618   }
41619   jresult = (void *)result;
41620   return jresult;
41621 }
41622
41623
41624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
41625   void * jresult ;
41626   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41627   Dali::Rect< int > result;
41628
41629   arg1 = (Dali::NinePatchImage *)jarg1;
41630   {
41631     try {
41632       result = (arg1)->GetChildRectangle();
41633     } catch (std::out_of_range& e) {
41634       {
41635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41636       };
41637     } catch (std::exception& e) {
41638       {
41639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41640       };
41641     } catch (...) {
41642       {
41643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41644       };
41645     }
41646   }
41647   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
41648   return jresult;
41649 }
41650
41651
41652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
41653   void * jresult ;
41654   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
41655   Dali::BufferImage result;
41656
41657   arg1 = (Dali::NinePatchImage *)jarg1;
41658   {
41659     try {
41660       result = (arg1)->CreateCroppedBufferImage();
41661     } catch (std::out_of_range& e) {
41662       {
41663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41664       };
41665     } catch (std::exception& e) {
41666       {
41667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (...) {
41670       {
41671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41672       };
41673     }
41674   }
41675   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41676   return jresult;
41677 }
41678
41679
41680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
41681   unsigned int jresult ;
41682   std::string *arg1 = 0 ;
41683   bool result;
41684
41685   if (!jarg1) {
41686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
41687     return 0;
41688   }
41689   std::string arg1_str(jarg1);
41690   arg1 = &arg1_str;
41691   {
41692     try {
41693       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
41694     } catch (std::out_of_range& e) {
41695       {
41696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41697       };
41698     } catch (std::exception& e) {
41699       {
41700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41701       };
41702     } catch (...) {
41703       {
41704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41705       };
41706     }
41707   }
41708   jresult = result;
41709
41710   //argout typemap for const std::string&
41711
41712   return jresult;
41713 }
41714
41715
41716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
41717   int jresult ;
41718   int result;
41719
41720   result = (int)Dali::CameraActor::Property::TYPE;
41721   jresult = (int)result;
41722   return jresult;
41723 }
41724
41725
41726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
41727   int jresult ;
41728   int result;
41729
41730   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
41731   jresult = (int)result;
41732   return jresult;
41733 }
41734
41735
41736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
41737   int jresult ;
41738   int result;
41739
41740   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
41741   jresult = (int)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
41747   int jresult ;
41748   int result;
41749
41750   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
41751   jresult = (int)result;
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
41757   int jresult ;
41758   int result;
41759
41760   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
41761   jresult = (int)result;
41762   return jresult;
41763 }
41764
41765
41766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
41767   int jresult ;
41768   int result;
41769
41770   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
41771   jresult = (int)result;
41772   return jresult;
41773 }
41774
41775
41776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
41777   int jresult ;
41778   int result;
41779
41780   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
41781   jresult = (int)result;
41782   return jresult;
41783 }
41784
41785
41786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
41787   int jresult ;
41788   int result;
41789
41790   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
41791   jresult = (int)result;
41792   return jresult;
41793 }
41794
41795
41796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
41797   int jresult ;
41798   int result;
41799
41800   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
41801   jresult = (int)result;
41802   return jresult;
41803 }
41804
41805
41806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
41807   int jresult ;
41808   int result;
41809
41810   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
41811   jresult = (int)result;
41812   return jresult;
41813 }
41814
41815
41816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
41817   int jresult ;
41818   int result;
41819
41820   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
41821   jresult = (int)result;
41822   return jresult;
41823 }
41824
41825
41826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
41827   int jresult ;
41828   int result;
41829
41830   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
41831   jresult = (int)result;
41832   return jresult;
41833 }
41834
41835
41836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
41837   int jresult ;
41838   int result;
41839
41840   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
41841   jresult = (int)result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
41847   int jresult ;
41848   int result;
41849
41850   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
41851   jresult = (int)result;
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
41857   void * jresult ;
41858   Dali::CameraActor::Property *result = 0 ;
41859
41860   {
41861     try {
41862       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
41863     } catch (std::out_of_range& e) {
41864       {
41865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41866       };
41867     } catch (std::exception& e) {
41868       {
41869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (...) {
41872       {
41873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41874       };
41875     }
41876   }
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
41883   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
41884
41885   arg1 = (Dali::CameraActor::Property *)jarg1;
41886   {
41887     try {
41888       delete arg1;
41889     } catch (std::out_of_range& e) {
41890       {
41891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41892       };
41893     } catch (std::exception& e) {
41894       {
41895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41896       };
41897     } catch (...) {
41898       {
41899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41900       };
41901     }
41902   }
41903 }
41904
41905
41906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
41907   void * jresult ;
41908   Dali::CameraActor *result = 0 ;
41909
41910   {
41911     try {
41912       result = (Dali::CameraActor *)new Dali::CameraActor();
41913     } catch (std::out_of_range& e) {
41914       {
41915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41916       };
41917     } catch (std::exception& e) {
41918       {
41919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (...) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41924       };
41925     }
41926   }
41927   jresult = (void *)result;
41928   return jresult;
41929 }
41930
41931
41932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
41933   void * jresult ;
41934   Dali::CameraActor result;
41935
41936   {
41937     try {
41938       result = Dali::CameraActor::New();
41939     } catch (std::out_of_range& e) {
41940       {
41941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41942       };
41943     } catch (std::exception& e) {
41944       {
41945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41946       };
41947     } catch (...) {
41948       {
41949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41950       };
41951     }
41952   }
41953   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41954   return jresult;
41955 }
41956
41957
41958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
41959   void * jresult ;
41960   Dali::Size *arg1 = 0 ;
41961   Dali::CameraActor result;
41962
41963   arg1 = (Dali::Size *)jarg1;
41964   if (!arg1) {
41965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
41966     return 0;
41967   }
41968   {
41969     try {
41970       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
41971     } catch (std::out_of_range& e) {
41972       {
41973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41974       };
41975     } catch (std::exception& e) {
41976       {
41977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41978       };
41979     } catch (...) {
41980       {
41981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41982       };
41983     }
41984   }
41985   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
41986   return jresult;
41987 }
41988
41989
41990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
41991   void * jresult ;
41992   Dali::BaseHandle arg1 ;
41993   Dali::BaseHandle *argp1 ;
41994   Dali::CameraActor result;
41995
41996   argp1 = (Dali::BaseHandle *)jarg1;
41997   if (!argp1) {
41998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41999     return 0;
42000   }
42001   arg1 = *argp1;
42002   {
42003     try {
42004       result = Dali::CameraActor::DownCast(arg1);
42005     } catch (std::out_of_range& e) {
42006       {
42007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42008       };
42009     } catch (std::exception& e) {
42010       {
42011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (...) {
42014       {
42015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42016       };
42017     }
42018   }
42019   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
42025   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42026
42027   arg1 = (Dali::CameraActor *)jarg1;
42028   {
42029     try {
42030       delete arg1;
42031     } catch (std::out_of_range& e) {
42032       {
42033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42034       };
42035     } catch (std::exception& e) {
42036       {
42037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42038       };
42039     } catch (...) {
42040       {
42041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42042       };
42043     }
42044   }
42045 }
42046
42047
42048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
42049   void * jresult ;
42050   Dali::CameraActor *arg1 = 0 ;
42051   Dali::CameraActor *result = 0 ;
42052
42053   arg1 = (Dali::CameraActor *)jarg1;
42054   if (!arg1) {
42055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42056     return 0;
42057   }
42058   {
42059     try {
42060       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
42061     } catch (std::out_of_range& e) {
42062       {
42063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42064       };
42065     } catch (std::exception& e) {
42066       {
42067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42068       };
42069     } catch (...) {
42070       {
42071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42072       };
42073     }
42074   }
42075   jresult = (void *)result;
42076   return jresult;
42077 }
42078
42079
42080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
42081   void * jresult ;
42082   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42083   Dali::CameraActor *arg2 = 0 ;
42084   Dali::CameraActor *result = 0 ;
42085
42086   arg1 = (Dali::CameraActor *)jarg1;
42087   arg2 = (Dali::CameraActor *)jarg2;
42088   if (!arg2) {
42089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
42090     return 0;
42091   }
42092   {
42093     try {
42094       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
42095     } catch (std::out_of_range& e) {
42096       {
42097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (std::exception& e) {
42100       {
42101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42102       };
42103     } catch (...) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42106       };
42107     }
42108   }
42109   jresult = (void *)result;
42110   return jresult;
42111 }
42112
42113
42114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
42115   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42116   Dali::Camera::Type arg2 ;
42117
42118   arg1 = (Dali::CameraActor *)jarg1;
42119   arg2 = (Dali::Camera::Type)jarg2;
42120   {
42121     try {
42122       (arg1)->SetType(arg2);
42123     } catch (std::out_of_range& e) {
42124       {
42125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42126       };
42127     } catch (std::exception& e) {
42128       {
42129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42130       };
42131     } catch (...) {
42132       {
42133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42134       };
42135     }
42136   }
42137 }
42138
42139
42140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
42141   int jresult ;
42142   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42143   Dali::Camera::Type result;
42144
42145   arg1 = (Dali::CameraActor *)jarg1;
42146   {
42147     try {
42148       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
42149     } catch (std::out_of_range& e) {
42150       {
42151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42152       };
42153     } catch (std::exception& e) {
42154       {
42155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42156       };
42157     } catch (...) {
42158       {
42159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42160       };
42161     }
42162   }
42163   jresult = (int)result;
42164   return jresult;
42165 }
42166
42167
42168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
42169   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42170   Dali::Camera::ProjectionMode arg2 ;
42171
42172   arg1 = (Dali::CameraActor *)jarg1;
42173   arg2 = (Dali::Camera::ProjectionMode)jarg2;
42174   {
42175     try {
42176       (arg1)->SetProjectionMode(arg2);
42177     } catch (std::out_of_range& e) {
42178       {
42179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42180       };
42181     } catch (std::exception& e) {
42182       {
42183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42184       };
42185     } catch (...) {
42186       {
42187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42188       };
42189     }
42190   }
42191 }
42192
42193
42194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
42195   int jresult ;
42196   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42197   Dali::Camera::ProjectionMode result;
42198
42199   arg1 = (Dali::CameraActor *)jarg1;
42200   {
42201     try {
42202       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
42203     } catch (std::out_of_range& e) {
42204       {
42205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42206       };
42207     } catch (std::exception& e) {
42208       {
42209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42210       };
42211     } catch (...) {
42212       {
42213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42214       };
42215     }
42216   }
42217   jresult = (int)result;
42218   return jresult;
42219 }
42220
42221
42222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
42223   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42224   float arg2 ;
42225
42226   arg1 = (Dali::CameraActor *)jarg1;
42227   arg2 = (float)jarg2;
42228   {
42229     try {
42230       (arg1)->SetFieldOfView(arg2);
42231     } catch (std::out_of_range& e) {
42232       {
42233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42234       };
42235     } catch (std::exception& e) {
42236       {
42237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42238       };
42239     } catch (...) {
42240       {
42241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42242       };
42243     }
42244   }
42245 }
42246
42247
42248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
42249   float jresult ;
42250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42251   float result;
42252
42253   arg1 = (Dali::CameraActor *)jarg1;
42254   {
42255     try {
42256       result = (float)(arg1)->GetFieldOfView();
42257     } catch (std::out_of_range& e) {
42258       {
42259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42260       };
42261     } catch (std::exception& e) {
42262       {
42263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42264       };
42265     } catch (...) {
42266       {
42267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42268       };
42269     }
42270   }
42271   jresult = result;
42272   return jresult;
42273 }
42274
42275
42276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
42277   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42278   float arg2 ;
42279
42280   arg1 = (Dali::CameraActor *)jarg1;
42281   arg2 = (float)jarg2;
42282   {
42283     try {
42284       (arg1)->SetAspectRatio(arg2);
42285     } catch (std::out_of_range& e) {
42286       {
42287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42288       };
42289     } catch (std::exception& e) {
42290       {
42291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42292       };
42293     } catch (...) {
42294       {
42295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42296       };
42297     }
42298   }
42299 }
42300
42301
42302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
42303   float jresult ;
42304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42305   float result;
42306
42307   arg1 = (Dali::CameraActor *)jarg1;
42308   {
42309     try {
42310       result = (float)(arg1)->GetAspectRatio();
42311     } catch (std::out_of_range& e) {
42312       {
42313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42314       };
42315     } catch (std::exception& e) {
42316       {
42317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (...) {
42320       {
42321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42322       };
42323     }
42324   }
42325   jresult = result;
42326   return jresult;
42327 }
42328
42329
42330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
42331   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42332   float arg2 ;
42333
42334   arg1 = (Dali::CameraActor *)jarg1;
42335   arg2 = (float)jarg2;
42336   {
42337     try {
42338       (arg1)->SetNearClippingPlane(arg2);
42339     } catch (std::out_of_range& e) {
42340       {
42341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42342       };
42343     } catch (std::exception& e) {
42344       {
42345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42350       };
42351     }
42352   }
42353 }
42354
42355
42356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
42357   float jresult ;
42358   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42359   float result;
42360
42361   arg1 = (Dali::CameraActor *)jarg1;
42362   {
42363     try {
42364       result = (float)(arg1)->GetNearClippingPlane();
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42376       };
42377     }
42378   }
42379   jresult = result;
42380   return jresult;
42381 }
42382
42383
42384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
42385   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42386   float arg2 ;
42387
42388   arg1 = (Dali::CameraActor *)jarg1;
42389   arg2 = (float)jarg2;
42390   {
42391     try {
42392       (arg1)->SetFarClippingPlane(arg2);
42393     } catch (std::out_of_range& e) {
42394       {
42395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42396       };
42397     } catch (std::exception& e) {
42398       {
42399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42400       };
42401     } catch (...) {
42402       {
42403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42404       };
42405     }
42406   }
42407 }
42408
42409
42410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
42411   float jresult ;
42412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42413   float result;
42414
42415   arg1 = (Dali::CameraActor *)jarg1;
42416   {
42417     try {
42418       result = (float)(arg1)->GetFarClippingPlane();
42419     } catch (std::out_of_range& e) {
42420       {
42421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42422       };
42423     } catch (std::exception& e) {
42424       {
42425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42426       };
42427     } catch (...) {
42428       {
42429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42430       };
42431     }
42432   }
42433   jresult = result;
42434   return jresult;
42435 }
42436
42437
42438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
42439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42440   Dali::Vector3 *arg2 = 0 ;
42441
42442   arg1 = (Dali::CameraActor *)jarg1;
42443   arg2 = (Dali::Vector3 *)jarg2;
42444   if (!arg2) {
42445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42446     return ;
42447   }
42448   {
42449     try {
42450       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
42451     } catch (std::out_of_range& e) {
42452       {
42453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42454       };
42455     } catch (std::exception& e) {
42456       {
42457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42458       };
42459     } catch (...) {
42460       {
42461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42462       };
42463     }
42464   }
42465 }
42466
42467
42468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
42469   void * jresult ;
42470   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42471   Dali::Vector3 result;
42472
42473   arg1 = (Dali::CameraActor *)jarg1;
42474   {
42475     try {
42476       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
42477     } catch (std::out_of_range& e) {
42478       {
42479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42480       };
42481     } catch (std::exception& e) {
42482       {
42483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42484       };
42485     } catch (...) {
42486       {
42487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42488       };
42489     }
42490   }
42491   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42492   return jresult;
42493 }
42494
42495
42496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
42497   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42498   bool arg2 ;
42499
42500   arg1 = (Dali::CameraActor *)jarg1;
42501   arg2 = jarg2 ? true : false;
42502   {
42503     try {
42504       (arg1)->SetInvertYAxis(arg2);
42505     } catch (std::out_of_range& e) {
42506       {
42507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42508       };
42509     } catch (std::exception& e) {
42510       {
42511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42512       };
42513     } catch (...) {
42514       {
42515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42516       };
42517     }
42518   }
42519 }
42520
42521
42522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
42523   unsigned int jresult ;
42524   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42525   bool result;
42526
42527   arg1 = (Dali::CameraActor *)jarg1;
42528   {
42529     try {
42530       result = (bool)(arg1)->GetInvertYAxis();
42531     } catch (std::out_of_range& e) {
42532       {
42533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42534       };
42535     } catch (std::exception& e) {
42536       {
42537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42538       };
42539     } catch (...) {
42540       {
42541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42542       };
42543     }
42544   }
42545   jresult = result;
42546   return jresult;
42547 }
42548
42549
42550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
42551   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42552   Dali::Size *arg2 = 0 ;
42553
42554   arg1 = (Dali::CameraActor *)jarg1;
42555   arg2 = (Dali::Size *)jarg2;
42556   if (!arg2) {
42557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42558     return ;
42559   }
42560   {
42561     try {
42562       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
42563     } catch (std::out_of_range& e) {
42564       {
42565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42566       };
42567     } catch (std::exception& e) {
42568       {
42569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42570       };
42571     } catch (...) {
42572       {
42573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42574       };
42575     }
42576   }
42577 }
42578
42579
42580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
42581   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42582   Dali::Size *arg2 = 0 ;
42583
42584   arg1 = (Dali::CameraActor *)jarg1;
42585   arg2 = (Dali::Size *)jarg2;
42586   if (!arg2) {
42587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
42588     return ;
42589   }
42590   {
42591     try {
42592       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
42593     } catch (std::out_of_range& e) {
42594       {
42595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42596       };
42597     } catch (std::exception& e) {
42598       {
42599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42600       };
42601     } catch (...) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42604       };
42605     }
42606   }
42607 }
42608
42609
42610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
42611   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
42612   float arg2 ;
42613   float arg3 ;
42614   float arg4 ;
42615   float arg5 ;
42616   float arg6 ;
42617   float arg7 ;
42618
42619   arg1 = (Dali::CameraActor *)jarg1;
42620   arg2 = (float)jarg2;
42621   arg3 = (float)jarg3;
42622   arg4 = (float)jarg4;
42623   arg5 = (float)jarg5;
42624   arg6 = (float)jarg6;
42625   arg7 = (float)jarg7;
42626   {
42627     try {
42628       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
42629     } catch (std::out_of_range& e) {
42630       {
42631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42632       };
42633     } catch (std::exception& e) {
42634       {
42635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42636       };
42637     } catch (...) {
42638       {
42639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42640       };
42641     }
42642   }
42643 }
42644
42645
42646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
42647   void * jresult ;
42648   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42649
42650   {
42651     try {
42652       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
42653     } catch (std::out_of_range& e) {
42654       {
42655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42656       };
42657     } catch (std::exception& e) {
42658       {
42659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (...) {
42662       {
42663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42664       };
42665     }
42666   }
42667   jresult = (void *)result;
42668   return jresult;
42669 }
42670
42671
42672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
42673   void * jresult ;
42674   std::string arg1 ;
42675   Dali::Property::Value arg2 ;
42676   Dali::Property::Value *argp2 ;
42677   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42678
42679   if (!jarg1) {
42680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42681     return 0;
42682   }
42683   (&arg1)->assign(jarg1);
42684   argp2 = (Dali::Property::Value *)jarg2;
42685   if (!argp2) {
42686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42687     return 0;
42688   }
42689   arg2 = *argp2;
42690   {
42691     try {
42692       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
42693     } catch (std::out_of_range& e) {
42694       {
42695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42696       };
42697     } catch (std::exception& e) {
42698       {
42699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42700       };
42701     } catch (...) {
42702       {
42703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42704       };
42705     }
42706   }
42707   jresult = (void *)result;
42708   return jresult;
42709 }
42710
42711
42712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
42713   void * jresult ;
42714   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
42715   std::pair< std::string,Dali::Property::Value > *result = 0 ;
42716
42717   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42718   if (!arg1) {
42719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
42720     return 0;
42721   }
42722   {
42723     try {
42724       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);
42725     } catch (std::out_of_range& e) {
42726       {
42727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42728       };
42729     } catch (std::exception& e) {
42730       {
42731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42732       };
42733     } catch (...) {
42734       {
42735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42736       };
42737     }
42738   }
42739   jresult = (void *)result;
42740   return jresult;
42741 }
42742
42743
42744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
42745   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42746   std::string *arg2 = 0 ;
42747
42748   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42749   if (!jarg2) {
42750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42751     return ;
42752   }
42753   std::string arg2_str(jarg2);
42754   arg2 = &arg2_str;
42755   if (arg1) (arg1)->first = *arg2;
42756
42757   //argout typemap for const std::string&
42758
42759 }
42760
42761
42762 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
42763   char * jresult ;
42764   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42765   std::string *result = 0 ;
42766
42767   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42768   result = (std::string *) & ((arg1)->first);
42769   jresult = SWIG_csharp_string_callback(result->c_str());
42770   return jresult;
42771 }
42772
42773
42774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
42775   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42776   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
42777
42778   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42779   arg2 = (Dali::Property::Value *)jarg2;
42780   if (arg1) (arg1)->second = *arg2;
42781 }
42782
42783
42784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
42785   void * jresult ;
42786   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42787   Dali::Property::Value *result = 0 ;
42788
42789   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42790   result = (Dali::Property::Value *)& ((arg1)->second);
42791   jresult = (void *)result;
42792   return jresult;
42793 }
42794
42795
42796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
42797   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
42798
42799   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
42800   {
42801     try {
42802       delete arg1;
42803     } catch (std::out_of_range& e) {
42804       {
42805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42806       };
42807     } catch (std::exception& e) {
42808       {
42809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42810       };
42811     } catch (...) {
42812       {
42813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42814       };
42815     }
42816   }
42817 }
42818
42819
42820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
42821   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42822
42823   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42824   {
42825     try {
42826       (arg1)->clear();
42827     } catch (std::out_of_range& e) {
42828       {
42829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42830       };
42831     } catch (std::exception& e) {
42832       {
42833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42834       };
42835     } catch (...) {
42836       {
42837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42838       };
42839     }
42840   }
42841 }
42842
42843
42844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
42845   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42846   Dali::TouchPoint *arg2 = 0 ;
42847
42848   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42849   arg2 = (Dali::TouchPoint *)jarg2;
42850   if (!arg2) {
42851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
42852     return ;
42853   }
42854   {
42855     try {
42856       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
42857     } catch (std::out_of_range& e) {
42858       {
42859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42860       };
42861     } catch (std::exception& e) {
42862       {
42863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42864       };
42865     } catch (...) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42868       };
42869     }
42870   }
42871 }
42872
42873
42874 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
42875   unsigned long jresult ;
42876   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42877   std::vector< Dali::TouchPoint >::size_type result;
42878
42879   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42880   {
42881     try {
42882       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
42883     } catch (std::out_of_range& e) {
42884       {
42885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42886       };
42887     } catch (std::exception& e) {
42888       {
42889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42890       };
42891     } catch (...) {
42892       {
42893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42894       };
42895     }
42896   }
42897   jresult = (unsigned long)result;
42898   return jresult;
42899 }
42900
42901
42902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
42903   unsigned long jresult ;
42904   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42905   std::vector< Dali::TouchPoint >::size_type result;
42906
42907   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42908   {
42909     try {
42910       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (...) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42922       };
42923     }
42924   }
42925   jresult = (unsigned long)result;
42926   return jresult;
42927 }
42928
42929
42930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
42931   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
42932   std::vector< Dali::TouchPoint >::size_type arg2 ;
42933
42934   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42935   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
42936   {
42937     try {
42938       (arg1)->reserve(arg2);
42939     } catch (std::out_of_range& e) {
42940       {
42941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42942       };
42943     } catch (std::exception& e) {
42944       {
42945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42950       };
42951     }
42952   }
42953 }
42954
42955
42956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
42957   void * jresult ;
42958   std::vector< Dali::TouchPoint > *result = 0 ;
42959
42960   {
42961     try {
42962       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (...) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42974       };
42975     }
42976   }
42977   jresult = (void *)result;
42978   return jresult;
42979 }
42980
42981
42982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
42983   void * jresult ;
42984   std::vector< Dali::TouchPoint > *arg1 = 0 ;
42985   std::vector< Dali::TouchPoint > *result = 0 ;
42986
42987   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
42988   if (!arg1) {
42989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
42990     return 0;
42991   }
42992   {
42993     try {
42994       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
42995     } catch (std::out_of_range& e) {
42996       {
42997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42998       };
42999     } catch (std::exception& e) {
43000       {
43001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43002       };
43003     } catch (...) {
43004       {
43005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43006       };
43007     }
43008   }
43009   jresult = (void *)result;
43010   return jresult;
43011 }
43012
43013
43014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
43015   void * jresult ;
43016   int arg1 ;
43017   std::vector< Dali::TouchPoint > *result = 0 ;
43018
43019   arg1 = (int)jarg1;
43020   {
43021     try {
43022       try {
43023         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
43024       }
43025       catch(std::out_of_range &_e) {
43026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43027         return 0;
43028       }
43029
43030     } catch (std::out_of_range& e) {
43031       {
43032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (std::exception& e) {
43035       {
43036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43037       };
43038     } catch (...) {
43039       {
43040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43041       };
43042     }
43043   }
43044   jresult = (void *)result;
43045   return jresult;
43046 }
43047
43048
43049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
43050   void * jresult ;
43051   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43052   int arg2 ;
43053   SwigValueWrapper< Dali::TouchPoint > result;
43054
43055   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43056   arg2 = (int)jarg2;
43057   {
43058     try {
43059       try {
43060         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
43061       }
43062       catch(std::out_of_range &_e) {
43063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43064         return 0;
43065       }
43066
43067     } catch (std::out_of_range& e) {
43068       {
43069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43070       };
43071     } catch (std::exception& e) {
43072       {
43073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43074       };
43075     } catch (...) {
43076       {
43077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43078       };
43079     }
43080   }
43081   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
43082   return jresult;
43083 }
43084
43085
43086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
43087   void * jresult ;
43088   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43089   int arg2 ;
43090   Dali::TouchPoint *result = 0 ;
43091
43092   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43093   arg2 = (int)jarg2;
43094   {
43095     try {
43096       try {
43097         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
43098       }
43099       catch(std::out_of_range &_e) {
43100         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43101         return 0;
43102       }
43103
43104     } catch (std::out_of_range& e) {
43105       {
43106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43107       };
43108     } catch (std::exception& e) {
43109       {
43110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43111       };
43112     } catch (...) {
43113       {
43114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43115       };
43116     }
43117   }
43118   jresult = (void *)result;
43119   return jresult;
43120 }
43121
43122
43123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
43124   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43125   int arg2 ;
43126   Dali::TouchPoint *arg3 = 0 ;
43127
43128   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43129   arg2 = (int)jarg2;
43130   arg3 = (Dali::TouchPoint *)jarg3;
43131   if (!arg3) {
43132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43133     return ;
43134   }
43135   {
43136     try {
43137       try {
43138         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43139       }
43140       catch(std::out_of_range &_e) {
43141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43142         return ;
43143       }
43144
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43152       };
43153     } catch (...) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43156       };
43157     }
43158   }
43159 }
43160
43161
43162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
43163   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43164   std::vector< Dali::TouchPoint > *arg2 = 0 ;
43165
43166   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43167   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
43168   if (!arg2) {
43169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43170     return ;
43171   }
43172   {
43173     try {
43174       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
43175     } catch (std::out_of_range& e) {
43176       {
43177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43178       };
43179     } catch (std::exception& e) {
43180       {
43181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43182       };
43183     } catch (...) {
43184       {
43185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43186       };
43187     }
43188   }
43189 }
43190
43191
43192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
43193   void * jresult ;
43194   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43195   int arg2 ;
43196   int arg3 ;
43197   std::vector< Dali::TouchPoint > *result = 0 ;
43198
43199   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43200   arg2 = (int)jarg2;
43201   arg3 = (int)jarg3;
43202   {
43203     try {
43204       try {
43205         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
43206       }
43207       catch(std::out_of_range &_e) {
43208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43209         return 0;
43210       }
43211       catch(std::invalid_argument &_e) {
43212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43213         return 0;
43214       }
43215
43216     } catch (std::out_of_range& e) {
43217       {
43218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43219       };
43220     } catch (std::exception& e) {
43221       {
43222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43223       };
43224     } catch (...) {
43225       {
43226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43227       };
43228     }
43229   }
43230   jresult = (void *)result;
43231   return jresult;
43232 }
43233
43234
43235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
43236   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43237   int arg2 ;
43238   Dali::TouchPoint *arg3 = 0 ;
43239
43240   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43241   arg2 = (int)jarg2;
43242   arg3 = (Dali::TouchPoint *)jarg3;
43243   if (!arg3) {
43244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43245     return ;
43246   }
43247   {
43248     try {
43249       try {
43250         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
43251       }
43252       catch(std::out_of_range &_e) {
43253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43254         return ;
43255       }
43256
43257     } catch (std::out_of_range& e) {
43258       {
43259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43260       };
43261     } catch (std::exception& e) {
43262       {
43263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43264       };
43265     } catch (...) {
43266       {
43267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43268       };
43269     }
43270   }
43271 }
43272
43273
43274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
43275   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43276   int arg2 ;
43277   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43278
43279   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43280   arg2 = (int)jarg2;
43281   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43282   if (!arg3) {
43283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43284     return ;
43285   }
43286   {
43287     try {
43288       try {
43289         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43290       }
43291       catch(std::out_of_range &_e) {
43292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43293         return ;
43294       }
43295
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43303       };
43304     } catch (...) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43307       };
43308     }
43309   }
43310 }
43311
43312
43313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
43314   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43315   int arg2 ;
43316
43317   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43318   arg2 = (int)jarg2;
43319   {
43320     try {
43321       try {
43322         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
43323       }
43324       catch(std::out_of_range &_e) {
43325         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43326         return ;
43327       }
43328
43329     } catch (std::out_of_range& e) {
43330       {
43331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43332       };
43333     } catch (std::exception& e) {
43334       {
43335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43336       };
43337     } catch (...) {
43338       {
43339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43340       };
43341     }
43342   }
43343 }
43344
43345
43346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
43347   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43348   int arg2 ;
43349   int arg3 ;
43350
43351   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43352   arg2 = (int)jarg2;
43353   arg3 = (int)jarg3;
43354   {
43355     try {
43356       try {
43357         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
43358       }
43359       catch(std::out_of_range &_e) {
43360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43361         return ;
43362       }
43363       catch(std::invalid_argument &_e) {
43364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43365         return ;
43366       }
43367
43368     } catch (std::out_of_range& e) {
43369       {
43370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43371       };
43372     } catch (std::exception& e) {
43373       {
43374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43375       };
43376     } catch (...) {
43377       {
43378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43379       };
43380     }
43381   }
43382 }
43383
43384
43385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
43386   void * jresult ;
43387   Dali::TouchPoint *arg1 = 0 ;
43388   int arg2 ;
43389   std::vector< Dali::TouchPoint > *result = 0 ;
43390
43391   arg1 = (Dali::TouchPoint *)jarg1;
43392   if (!arg1) {
43393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
43394     return 0;
43395   }
43396   arg2 = (int)jarg2;
43397   {
43398     try {
43399       try {
43400         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
43401       }
43402       catch(std::out_of_range &_e) {
43403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43404         return 0;
43405       }
43406
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
43427   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43428
43429   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43430   {
43431     try {
43432       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
43433     } catch (std::out_of_range& e) {
43434       {
43435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43436       };
43437     } catch (std::exception& e) {
43438       {
43439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43440       };
43441     } catch (...) {
43442       {
43443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43444       };
43445     }
43446   }
43447 }
43448
43449
43450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
43451   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43452   int arg2 ;
43453   int arg3 ;
43454
43455   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43456   arg2 = (int)jarg2;
43457   arg3 = (int)jarg3;
43458   {
43459     try {
43460       try {
43461         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
43462       }
43463       catch(std::out_of_range &_e) {
43464         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43465         return ;
43466       }
43467       catch(std::invalid_argument &_e) {
43468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
43469         return ;
43470       }
43471
43472     } catch (std::out_of_range& e) {
43473       {
43474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43475       };
43476     } catch (std::exception& e) {
43477       {
43478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43479       };
43480     } catch (...) {
43481       {
43482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43483       };
43484     }
43485   }
43486 }
43487
43488
43489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
43490   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43491   int arg2 ;
43492   std::vector< Dali::TouchPoint > *arg3 = 0 ;
43493
43494   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43495   arg2 = (int)jarg2;
43496   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
43497   if (!arg3) {
43498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
43499     return ;
43500   }
43501   {
43502     try {
43503       try {
43504         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
43505       }
43506       catch(std::out_of_range &_e) {
43507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
43508         return ;
43509       }
43510
43511     } catch (std::out_of_range& e) {
43512       {
43513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43514       };
43515     } catch (std::exception& e) {
43516       {
43517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43518       };
43519     } catch (...) {
43520       {
43521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43522       };
43523     }
43524   }
43525 }
43526
43527
43528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
43529   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
43530
43531   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
43532   {
43533     try {
43534       delete arg1;
43535     } catch (std::out_of_range& e) {
43536       {
43537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43538       };
43539     } catch (std::exception& e) {
43540       {
43541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43542       };
43543     } catch (...) {
43544       {
43545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43546       };
43547     }
43548   }
43549 }
43550
43551
43552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
43553   void * jresult ;
43554   Dali::Rect< int > *result = 0 ;
43555
43556   {
43557     try {
43558       result = (Dali::Rect< int > *)new Dali::Rect< int >();
43559     } catch (std::out_of_range& e) {
43560       {
43561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43562       };
43563     } catch (std::exception& e) {
43564       {
43565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43566       };
43567     } catch (...) {
43568       {
43569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43570       };
43571     }
43572   }
43573   jresult = (void *)result;
43574   return jresult;
43575 }
43576
43577
43578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
43579   void * jresult ;
43580   int arg1 ;
43581   int arg2 ;
43582   int arg3 ;
43583   int arg4 ;
43584   Dali::Rect< int > *result = 0 ;
43585
43586   arg1 = (int)jarg1;
43587   arg2 = (int)jarg2;
43588   arg3 = (int)jarg3;
43589   arg4 = (int)jarg4;
43590   {
43591     try {
43592       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
43593     } catch (std::out_of_range& e) {
43594       {
43595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43596       };
43597     } catch (std::exception& e) {
43598       {
43599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43600       };
43601     } catch (...) {
43602       {
43603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43604       };
43605     }
43606   }
43607   jresult = (void *)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
43613   void * jresult ;
43614   Dali::Rect< int > *arg1 = 0 ;
43615   Dali::Rect< int > *result = 0 ;
43616
43617   arg1 = (Dali::Rect< int > *)jarg1;
43618   if (!arg1) {
43619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43620     return 0;
43621   }
43622   {
43623     try {
43624       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
43625     } catch (std::out_of_range& e) {
43626       {
43627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43628       };
43629     } catch (std::exception& e) {
43630       {
43631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43632       };
43633     } catch (...) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43636       };
43637     }
43638   }
43639   jresult = (void *)result;
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
43645   void * jresult ;
43646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43647   Dali::Rect< int > *arg2 = 0 ;
43648   Dali::Rect< int > *result = 0 ;
43649
43650   arg1 = (Dali::Rect< int > *)jarg1;
43651   arg2 = (Dali::Rect< int > *)jarg2;
43652   if (!arg2) {
43653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43654     return 0;
43655   }
43656   {
43657     try {
43658       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
43659     } catch (std::out_of_range& e) {
43660       {
43661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (std::exception& e) {
43664       {
43665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43670       };
43671     }
43672   }
43673   jresult = (void *)result;
43674   return jresult;
43675 }
43676
43677
43678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
43679   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43680   int arg2 ;
43681   int arg3 ;
43682   int arg4 ;
43683   int arg5 ;
43684
43685   arg1 = (Dali::Rect< int > *)jarg1;
43686   arg2 = (int)jarg2;
43687   arg3 = (int)jarg3;
43688   arg4 = (int)jarg4;
43689   arg5 = (int)jarg5;
43690   {
43691     try {
43692       (arg1)->Set(arg2,arg3,arg4,arg5);
43693     } catch (std::out_of_range& e) {
43694       {
43695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43696       };
43697     } catch (std::exception& e) {
43698       {
43699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43700       };
43701     } catch (...) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43704       };
43705     }
43706   }
43707 }
43708
43709
43710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
43711   unsigned int jresult ;
43712   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43713   bool result;
43714
43715   arg1 = (Dali::Rect< int > *)jarg1;
43716   {
43717     try {
43718       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
43719     } catch (std::out_of_range& e) {
43720       {
43721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (std::exception& e) {
43724       {
43725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43730       };
43731     }
43732   }
43733   jresult = result;
43734   return jresult;
43735 }
43736
43737
43738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
43739   int jresult ;
43740   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43741   int result;
43742
43743   arg1 = (Dali::Rect< int > *)jarg1;
43744   {
43745     try {
43746       result = (int)((Dali::Rect< int > const *)arg1)->Left();
43747     } catch (std::out_of_range& e) {
43748       {
43749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43750       };
43751     } catch (std::exception& e) {
43752       {
43753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43754       };
43755     } catch (...) {
43756       {
43757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43758       };
43759     }
43760   }
43761   jresult = result;
43762   return jresult;
43763 }
43764
43765
43766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
43767   int jresult ;
43768   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43769   int result;
43770
43771   arg1 = (Dali::Rect< int > *)jarg1;
43772   {
43773     try {
43774       result = (int)((Dali::Rect< int > const *)arg1)->Right();
43775     } catch (std::out_of_range& e) {
43776       {
43777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43778       };
43779     } catch (std::exception& e) {
43780       {
43781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43782       };
43783     } catch (...) {
43784       {
43785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43786       };
43787     }
43788   }
43789   jresult = result;
43790   return jresult;
43791 }
43792
43793
43794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
43795   int jresult ;
43796   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43797   int result;
43798
43799   arg1 = (Dali::Rect< int > *)jarg1;
43800   {
43801     try {
43802       result = (int)((Dali::Rect< int > const *)arg1)->Top();
43803     } catch (std::out_of_range& e) {
43804       {
43805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43806       };
43807     } catch (std::exception& e) {
43808       {
43809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43810       };
43811     } catch (...) {
43812       {
43813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43814       };
43815     }
43816   }
43817   jresult = result;
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
43823   int jresult ;
43824   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43825   int result;
43826
43827   arg1 = (Dali::Rect< int > *)jarg1;
43828   {
43829     try {
43830       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
43831     } catch (std::out_of_range& e) {
43832       {
43833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43834       };
43835     } catch (std::exception& e) {
43836       {
43837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43838       };
43839     } catch (...) {
43840       {
43841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43842       };
43843     }
43844   }
43845   jresult = result;
43846   return jresult;
43847 }
43848
43849
43850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
43851   int jresult ;
43852   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43853   int result;
43854
43855   arg1 = (Dali::Rect< int > *)jarg1;
43856   {
43857     try {
43858       result = (int)((Dali::Rect< int > const *)arg1)->Area();
43859     } catch (std::out_of_range& e) {
43860       {
43861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43862       };
43863     } catch (std::exception& e) {
43864       {
43865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43866       };
43867     } catch (...) {
43868       {
43869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43870       };
43871     }
43872   }
43873   jresult = result;
43874   return jresult;
43875 }
43876
43877
43878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
43879   unsigned int jresult ;
43880   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43881   Dali::Rect< int > *arg2 = 0 ;
43882   bool result;
43883
43884   arg1 = (Dali::Rect< int > *)jarg1;
43885   arg2 = (Dali::Rect< int > *)jarg2;
43886   if (!arg2) {
43887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43888     return 0;
43889   }
43890   {
43891     try {
43892       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
43893     } catch (std::out_of_range& e) {
43894       {
43895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43896       };
43897     } catch (std::exception& e) {
43898       {
43899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43900       };
43901     } catch (...) {
43902       {
43903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43904       };
43905     }
43906   }
43907   jresult = result;
43908   return jresult;
43909 }
43910
43911
43912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
43913   unsigned int jresult ;
43914   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43915   Dali::Rect< int > *arg2 = 0 ;
43916   bool result;
43917
43918   arg1 = (Dali::Rect< int > *)jarg1;
43919   arg2 = (Dali::Rect< int > *)jarg2;
43920   if (!arg2) {
43921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
43922     return 0;
43923   }
43924   {
43925     try {
43926       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
43927     } catch (std::out_of_range& e) {
43928       {
43929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43930       };
43931     } catch (std::exception& e) {
43932       {
43933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43934       };
43935     } catch (...) {
43936       {
43937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43938       };
43939     }
43940   }
43941   jresult = result;
43942   return jresult;
43943 }
43944
43945
43946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
43947   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43948   int arg2 ;
43949
43950   arg1 = (Dali::Rect< int > *)jarg1;
43951   arg2 = (int)jarg2;
43952   if (arg1) (arg1)->x = arg2;
43953 }
43954
43955
43956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
43957   int jresult ;
43958   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43959   int result;
43960
43961   arg1 = (Dali::Rect< int > *)jarg1;
43962   result = (int) ((arg1)->x);
43963   jresult = result;
43964   return jresult;
43965 }
43966
43967
43968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
43969   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43970   int arg2 ;
43971
43972   arg1 = (Dali::Rect< int > *)jarg1;
43973   arg2 = (int)jarg2;
43974   if (arg1) (arg1)->left = arg2;
43975 }
43976
43977
43978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
43979   int jresult ;
43980   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43981   int result;
43982
43983   arg1 = (Dali::Rect< int > *)jarg1;
43984   result = (int) ((arg1)->left);
43985   jresult = result;
43986   return jresult;
43987 }
43988
43989
43990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
43991   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
43992   int arg2 ;
43993
43994   arg1 = (Dali::Rect< int > *)jarg1;
43995   arg2 = (int)jarg2;
43996   if (arg1) (arg1)->y = arg2;
43997 }
43998
43999
44000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
44001   int jresult ;
44002   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44003   int result;
44004
44005   arg1 = (Dali::Rect< int > *)jarg1;
44006   result = (int) ((arg1)->y);
44007   jresult = result;
44008   return jresult;
44009 }
44010
44011
44012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
44013   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44014   int arg2 ;
44015
44016   arg1 = (Dali::Rect< int > *)jarg1;
44017   arg2 = (int)jarg2;
44018   if (arg1) (arg1)->right = arg2;
44019 }
44020
44021
44022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
44023   int jresult ;
44024   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44025   int result;
44026
44027   arg1 = (Dali::Rect< int > *)jarg1;
44028   result = (int) ((arg1)->right);
44029   jresult = result;
44030   return jresult;
44031 }
44032
44033
44034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
44035   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44036   int arg2 ;
44037
44038   arg1 = (Dali::Rect< int > *)jarg1;
44039   arg2 = (int)jarg2;
44040   if (arg1) (arg1)->width = arg2;
44041 }
44042
44043
44044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
44045   int jresult ;
44046   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44047   int result;
44048
44049   arg1 = (Dali::Rect< int > *)jarg1;
44050   result = (int) ((arg1)->width);
44051   jresult = result;
44052   return jresult;
44053 }
44054
44055
44056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
44057   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44058   int arg2 ;
44059
44060   arg1 = (Dali::Rect< int > *)jarg1;
44061   arg2 = (int)jarg2;
44062   if (arg1) (arg1)->bottom = arg2;
44063 }
44064
44065
44066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
44067   int jresult ;
44068   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44069   int result;
44070
44071   arg1 = (Dali::Rect< int > *)jarg1;
44072   result = (int) ((arg1)->bottom);
44073   jresult = result;
44074   return jresult;
44075 }
44076
44077
44078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
44079   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44080   int arg2 ;
44081
44082   arg1 = (Dali::Rect< int > *)jarg1;
44083   arg2 = (int)jarg2;
44084   if (arg1) (arg1)->height = arg2;
44085 }
44086
44087
44088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
44089   int jresult ;
44090   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44091   int result;
44092
44093   arg1 = (Dali::Rect< int > *)jarg1;
44094   result = (int) ((arg1)->height);
44095   jresult = result;
44096   return jresult;
44097 }
44098
44099
44100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
44101   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44102   int arg2 ;
44103
44104   arg1 = (Dali::Rect< int > *)jarg1;
44105   arg2 = (int)jarg2;
44106   if (arg1) (arg1)->top = arg2;
44107 }
44108
44109
44110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
44111   int jresult ;
44112   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44113   int result;
44114
44115   arg1 = (Dali::Rect< int > *)jarg1;
44116   result = (int) ((arg1)->top);
44117   jresult = result;
44118   return jresult;
44119 }
44120
44121
44122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
44123   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
44124
44125   arg1 = (Dali::Rect< int > *)jarg1;
44126   {
44127     try {
44128       delete arg1;
44129     } catch (std::out_of_range& e) {
44130       {
44131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44132       };
44133     } catch (std::exception& e) {
44134       {
44135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (...) {
44138       {
44139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44140       };
44141     }
44142   }
44143 }
44144
44145
44146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
44147   void * jresult ;
44148   Dali::Rect< float > *result = 0 ;
44149
44150   {
44151     try {
44152       result = (Dali::Rect< float > *)new Dali::Rect< float >();
44153     } catch (std::out_of_range& e) {
44154       {
44155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44156       };
44157     } catch (std::exception& e) {
44158       {
44159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44160       };
44161     } catch (...) {
44162       {
44163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44164       };
44165     }
44166   }
44167   jresult = (void *)result;
44168   return jresult;
44169 }
44170
44171
44172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
44173   void * jresult ;
44174   float arg1 ;
44175   float arg2 ;
44176   float arg3 ;
44177   float arg4 ;
44178   Dali::Rect< float > *result = 0 ;
44179
44180   arg1 = (float)jarg1;
44181   arg2 = (float)jarg2;
44182   arg3 = (float)jarg4;
44183   arg4 = (float)jarg3;
44184   {
44185     try {
44186       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
44187     } catch (std::out_of_range& e) {
44188       {
44189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44190       };
44191     } catch (std::exception& e) {
44192       {
44193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44194       };
44195     } catch (...) {
44196       {
44197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44198       };
44199     }
44200   }
44201   jresult = (void *)result;
44202   return jresult;
44203 }
44204
44205
44206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
44207   void * jresult ;
44208   Dali::Rect< float > *arg1 = 0 ;
44209   Dali::Rect< float > *result = 0 ;
44210
44211   arg1 = (Dali::Rect< float > *)jarg1;
44212   if (!arg1) {
44213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44214     return 0;
44215   }
44216   {
44217     try {
44218       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
44219     } catch (std::out_of_range& e) {
44220       {
44221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44222       };
44223     } catch (std::exception& e) {
44224       {
44225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44226       };
44227     } catch (...) {
44228       {
44229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44230       };
44231     }
44232   }
44233   jresult = (void *)result;
44234   return jresult;
44235 }
44236
44237
44238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
44239   void * jresult ;
44240   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44241   Dali::Rect< float > *arg2 = 0 ;
44242   Dali::Rect< float > *result = 0 ;
44243
44244   arg1 = (Dali::Rect< float > *)jarg1;
44245   arg2 = (Dali::Rect< float > *)jarg2;
44246   if (!arg2) {
44247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
44248     return 0;
44249   }
44250   {
44251     try {
44252       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
44253     } catch (std::out_of_range& e) {
44254       {
44255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44256       };
44257     } catch (std::exception& e) {
44258       {
44259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44260       };
44261     } catch (...) {
44262       {
44263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44264       };
44265     }
44266   }
44267   jresult = (void *)result;
44268   return jresult;
44269 }
44270
44271
44272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
44273   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44274   float arg2 ;
44275   float arg3 ;
44276   float arg4 ;
44277   float arg5 ;
44278
44279   arg1 = (Dali::Rect< float > *)jarg1;
44280   arg2 = (float)jarg2;
44281   arg3 = (float)jarg3;
44282   arg4 = (float)jarg5;
44283   arg5 = (float)jarg4;
44284   {
44285     try {
44286       (arg1)->Set(arg2,arg3,arg4,arg5);
44287     } catch (std::out_of_range& e) {
44288       {
44289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44290       };
44291     } catch (std::exception& e) {
44292       {
44293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (...) {
44296       {
44297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44298       };
44299     }
44300   }
44301 }
44302
44303
44304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
44305   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44306   float arg2 ;
44307
44308   arg1 = (Dali::Rect< float > *)jarg1;
44309   arg2 = (float)jarg2;
44310   if (arg1) (arg1)->left = arg2;
44311 }
44312
44313
44314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
44315   float jresult ;
44316   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44317   float result;
44318
44319   arg1 = (Dali::Rect< float > *)jarg1;
44320   result = (float) ((arg1)->left);
44321   jresult = result;
44322   return jresult;
44323 }
44324
44325
44326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
44327   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44328   float arg2 ;
44329
44330   arg1 = (Dali::Rect< float > *)jarg1;
44331   arg2 = (float)jarg2;
44332   if (arg1) (arg1)->left = arg2;
44333 }
44334
44335
44336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
44337   float jresult ;
44338   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44339   float result;
44340
44341   arg1 = (Dali::Rect< float > *)jarg1;
44342   result = (float) ((arg1)->left);
44343   jresult = result;
44344   return jresult;
44345 }
44346
44347
44348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
44349   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44350   float arg2 ;
44351
44352   arg1 = (Dali::Rect< float > *)jarg1;
44353   arg2 = (float)jarg2;
44354   if (arg1) (arg1)->right = arg2;
44355 }
44356
44357
44358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
44359   float jresult ;
44360   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44361   float result;
44362
44363   arg1 = (Dali::Rect< float > *)jarg1;
44364   result = (float) ((arg1)->right);
44365   jresult = result;
44366   return jresult;
44367 }
44368
44369
44370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
44371   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44372   float arg2 ;
44373
44374   arg1 = (Dali::Rect< float > *)jarg1;
44375   arg2 = (float)jarg2;
44376   if (arg1) (arg1)->right = arg2;
44377 }
44378
44379
44380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
44381   float jresult ;
44382   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44383   float result;
44384
44385   arg1 = (Dali::Rect< float > *)jarg1;
44386   result = (float) ((arg1)->right);
44387   jresult = result;
44388   return jresult;
44389 }
44390
44391
44392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
44393   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44394   float arg2 ;
44395
44396   arg1 = (Dali::Rect< float > *)jarg1;
44397   arg2 = (float)jarg2;
44398   if (arg1) (arg1)->bottom = arg2;
44399 }
44400
44401
44402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
44403   float jresult ;
44404   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44405   float result;
44406
44407   arg1 = (Dali::Rect< float > *)jarg1;
44408   result = (float) ((arg1)->bottom);
44409   jresult = result;
44410   return jresult;
44411 }
44412
44413
44414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
44415   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44416   float arg2 ;
44417
44418   arg1 = (Dali::Rect< float > *)jarg1;
44419   arg2 = (float)jarg2;
44420   if (arg1) (arg1)->top = arg2;
44421 }
44422
44423
44424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
44425   float jresult ;
44426   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44427   float result;
44428
44429   arg1 = (Dali::Rect< float > *)jarg1;
44430   result = (float) ((arg1)->top);
44431   jresult = result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
44437   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
44438
44439   arg1 = (Dali::Rect< float > *)jarg1;
44440   {
44441     try {
44442       delete arg1;
44443     } catch (std::out_of_range& e) {
44444       {
44445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44446       };
44447     } catch (std::exception& e) {
44448       {
44449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44450       };
44451     } catch (...) {
44452       {
44453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44454       };
44455     }
44456   }
44457 }
44458
44459
44460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
44461   int jresult ;
44462   int result;
44463
44464   result = (int)Dali::Vector< int >::BaseType;
44465   jresult = (int)result;
44466   return jresult;
44467 }
44468
44469
44470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
44471   void * jresult ;
44472   Dali::Vector< int > *result = 0 ;
44473
44474   {
44475     try {
44476       result = (Dali::Vector< int > *)new Dali::Vector< int >();
44477     } catch (std::out_of_range& e) {
44478       {
44479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44480       };
44481     } catch (std::exception& e) {
44482       {
44483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44484       };
44485     } catch (...) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44488       };
44489     }
44490   }
44491   jresult = (void *)result;
44492   return jresult;
44493 }
44494
44495
44496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
44497   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44498
44499   arg1 = (Dali::Vector< int > *)jarg1;
44500   {
44501     try {
44502       delete arg1;
44503     } catch (std::out_of_range& e) {
44504       {
44505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44506       };
44507     } catch (std::exception& e) {
44508       {
44509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44510       };
44511     } catch (...) {
44512       {
44513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44514       };
44515     }
44516   }
44517 }
44518
44519
44520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
44521   void * jresult ;
44522   Dali::Vector< int > *arg1 = 0 ;
44523   Dali::Vector< int > *result = 0 ;
44524
44525   arg1 = (Dali::Vector< int > *)jarg1;
44526   if (!arg1) {
44527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44528     return 0;
44529   }
44530   {
44531     try {
44532       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
44533     } catch (std::out_of_range& e) {
44534       {
44535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44536       };
44537     } catch (std::exception& e) {
44538       {
44539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44540       };
44541     } catch (...) {
44542       {
44543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44544       };
44545     }
44546   }
44547   jresult = (void *)result;
44548   return jresult;
44549 }
44550
44551
44552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
44553   void * jresult ;
44554   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44555   Dali::Vector< int > *arg2 = 0 ;
44556   Dali::Vector< int > *result = 0 ;
44557
44558   arg1 = (Dali::Vector< int > *)jarg1;
44559   arg2 = (Dali::Vector< int > *)jarg2;
44560   if (!arg2) {
44561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
44562     return 0;
44563   }
44564   {
44565     try {
44566       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
44567     } catch (std::out_of_range& e) {
44568       {
44569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44570       };
44571     } catch (std::exception& e) {
44572       {
44573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44574       };
44575     } catch (...) {
44576       {
44577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44578       };
44579     }
44580   }
44581   jresult = (void *)result;
44582   return jresult;
44583 }
44584
44585
44586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
44587   void * jresult ;
44588   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44589   Dali::Vector< int >::Iterator result;
44590
44591   arg1 = (Dali::Vector< int > *)jarg1;
44592   {
44593     try {
44594       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
44595     } catch (std::out_of_range& e) {
44596       {
44597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44598       };
44599     } catch (std::exception& e) {
44600       {
44601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44602       };
44603     } catch (...) {
44604       {
44605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44606       };
44607     }
44608   }
44609   jresult = (void *)result;
44610   return jresult;
44611 }
44612
44613
44614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
44615   void * jresult ;
44616   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44617   Dali::Vector< int >::Iterator result;
44618
44619   arg1 = (Dali::Vector< int > *)jarg1;
44620   {
44621     try {
44622       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
44623     } catch (std::out_of_range& e) {
44624       {
44625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44626       };
44627     } catch (std::exception& e) {
44628       {
44629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44630       };
44631     } catch (...) {
44632       {
44633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44634       };
44635     }
44636   }
44637   jresult = (void *)result;
44638   return jresult;
44639 }
44640
44641
44642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
44643   void * jresult ;
44644   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44645   Dali::Vector< int >::SizeType arg2 ;
44646   Dali::Vector< int >::ItemType *result = 0 ;
44647
44648   arg1 = (Dali::Vector< int > *)jarg1;
44649   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44650   {
44651     try {
44652       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
44653     } catch (std::out_of_range& e) {
44654       {
44655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44656       };
44657     } catch (std::exception& e) {
44658       {
44659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44660       };
44661     } catch (...) {
44662       {
44663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44664       };
44665     }
44666   }
44667   jresult = (void *)result;
44668   return jresult;
44669 }
44670
44671
44672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
44673   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44674   Dali::Vector< int >::ItemType *arg2 = 0 ;
44675   Dali::Vector< int >::ItemType temp2 ;
44676
44677   arg1 = (Dali::Vector< int > *)jarg1;
44678   temp2 = (Dali::Vector< int >::ItemType)jarg2;
44679   arg2 = &temp2;
44680   {
44681     try {
44682       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
44683     } catch (std::out_of_range& e) {
44684       {
44685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44686       };
44687     } catch (std::exception& e) {
44688       {
44689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44690       };
44691     } catch (...) {
44692       {
44693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44694       };
44695     }
44696   }
44697 }
44698
44699
44700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
44701   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44702   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44703   Dali::Vector< int >::ItemType *arg3 = 0 ;
44704   Dali::Vector< int >::ItemType temp3 ;
44705
44706   arg1 = (Dali::Vector< int > *)jarg1;
44707   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44708   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44709   arg3 = &temp3;
44710   {
44711     try {
44712       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44713     } catch (std::out_of_range& e) {
44714       {
44715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44716       };
44717     } catch (std::exception& e) {
44718       {
44719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44720       };
44721     } catch (...) {
44722       {
44723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44724       };
44725     }
44726   }
44727 }
44728
44729
44730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44731   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44732   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44733   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44734   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
44735
44736   arg1 = (Dali::Vector< int > *)jarg1;
44737   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44738   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44739   arg4 = (Dali::Vector< int >::Iterator)jarg4;
44740   {
44741     try {
44742       (arg1)->Insert(arg2,arg3,arg4);
44743     } catch (std::out_of_range& e) {
44744       {
44745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44746       };
44747     } catch (std::exception& e) {
44748       {
44749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44750       };
44751     } catch (...) {
44752       {
44753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44754       };
44755     }
44756   }
44757 }
44758
44759
44760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
44761   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44762   Dali::Vector< int >::SizeType arg2 ;
44763
44764   arg1 = (Dali::Vector< int > *)jarg1;
44765   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44766   {
44767     try {
44768       (arg1)->Reserve(arg2);
44769     } catch (std::out_of_range& e) {
44770       {
44771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44772       };
44773     } catch (std::exception& e) {
44774       {
44775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44780       };
44781     }
44782   }
44783 }
44784
44785
44786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
44787   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44788   Dali::Vector< int >::SizeType arg2 ;
44789
44790   arg1 = (Dali::Vector< int > *)jarg1;
44791   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44792   {
44793     try {
44794       (arg1)->Resize(arg2);
44795     } catch (std::out_of_range& e) {
44796       {
44797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44798       };
44799     } catch (std::exception& e) {
44800       {
44801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44802       };
44803     } catch (...) {
44804       {
44805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44806       };
44807     }
44808   }
44809 }
44810
44811
44812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
44813   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44814   Dali::Vector< int >::SizeType arg2 ;
44815   Dali::Vector< int >::ItemType *arg3 = 0 ;
44816   Dali::Vector< int >::ItemType temp3 ;
44817
44818   arg1 = (Dali::Vector< int > *)jarg1;
44819   arg2 = (Dali::Vector< int >::SizeType)jarg2;
44820   temp3 = (Dali::Vector< int >::ItemType)jarg3;
44821   arg3 = &temp3;
44822   {
44823     try {
44824       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44832       };
44833     } catch (...) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44836       };
44837     }
44838   }
44839 }
44840
44841
44842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
44843   void * jresult ;
44844   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44845   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44846   Dali::Vector< int >::Iterator result;
44847
44848   arg1 = (Dali::Vector< int > *)jarg1;
44849   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44850   {
44851     try {
44852       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
44853     } catch (std::out_of_range& e) {
44854       {
44855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44856       };
44857     } catch (std::exception& e) {
44858       {
44859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (...) {
44862       {
44863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44864       };
44865     }
44866   }
44867   jresult = (void *)result;
44868   return jresult;
44869 }
44870
44871
44872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
44873   void * jresult ;
44874   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44875   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44876   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
44877   Dali::Vector< int >::Iterator result;
44878
44879   arg1 = (Dali::Vector< int > *)jarg1;
44880   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44881   arg3 = (Dali::Vector< int >::Iterator)jarg3;
44882   {
44883     try {
44884       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
44885     } catch (std::out_of_range& e) {
44886       {
44887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44888       };
44889     } catch (std::exception& e) {
44890       {
44891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44892       };
44893     } catch (...) {
44894       {
44895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44896       };
44897     }
44898   }
44899   jresult = (void *)result;
44900   return jresult;
44901 }
44902
44903
44904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
44905   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44906   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
44907
44908   arg1 = (Dali::Vector< int > *)jarg1;
44909   arg2 = (Dali::Vector< int >::Iterator)jarg2;
44910   {
44911     try {
44912       (arg1)->Remove(arg2);
44913     } catch (std::out_of_range& e) {
44914       {
44915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (std::exception& e) {
44918       {
44919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44920       };
44921     } catch (...) {
44922       {
44923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44924       };
44925     }
44926   }
44927 }
44928
44929
44930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
44931   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44932   Dali::Vector< int > *arg2 = 0 ;
44933
44934   arg1 = (Dali::Vector< int > *)jarg1;
44935   arg2 = (Dali::Vector< int > *)jarg2;
44936   if (!arg2) {
44937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
44938     return ;
44939   }
44940   {
44941     try {
44942       (arg1)->Swap(*arg2);
44943     } catch (std::out_of_range& e) {
44944       {
44945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44946       };
44947     } catch (std::exception& e) {
44948       {
44949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44950       };
44951     } catch (...) {
44952       {
44953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44954       };
44955     }
44956   }
44957 }
44958
44959
44960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
44961   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44962
44963   arg1 = (Dali::Vector< int > *)jarg1;
44964   {
44965     try {
44966       (arg1)->Clear();
44967     } catch (std::out_of_range& e) {
44968       {
44969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44970       };
44971     } catch (std::exception& e) {
44972       {
44973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44974       };
44975     } catch (...) {
44976       {
44977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44978       };
44979     }
44980   }
44981 }
44982
44983
44984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
44985   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
44986
44987   arg1 = (Dali::Vector< int > *)jarg1;
44988   {
44989     try {
44990       (arg1)->Release();
44991     } catch (std::out_of_range& e) {
44992       {
44993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44994       };
44995     } catch (std::exception& e) {
44996       {
44997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44998       };
44999     } catch (...) {
45000       {
45001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45002       };
45003     }
45004   }
45005 }
45006
45007
45008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
45009   int jresult ;
45010   int result;
45011
45012   result = (int)Dali::Vector< float >::BaseType;
45013   jresult = (int)result;
45014   return jresult;
45015 }
45016
45017
45018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
45019   void * jresult ;
45020   Dali::Vector< float > *result = 0 ;
45021
45022   {
45023     try {
45024       result = (Dali::Vector< float > *)new Dali::Vector< float >();
45025     } catch (std::out_of_range& e) {
45026       {
45027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45028       };
45029     } catch (std::exception& e) {
45030       {
45031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45032       };
45033     } catch (...) {
45034       {
45035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45036       };
45037     }
45038   }
45039   jresult = (void *)result;
45040   return jresult;
45041 }
45042
45043
45044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
45045   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45046
45047   arg1 = (Dali::Vector< float > *)jarg1;
45048   {
45049     try {
45050       delete arg1;
45051     } catch (std::out_of_range& e) {
45052       {
45053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45054       };
45055     } catch (std::exception& e) {
45056       {
45057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45058       };
45059     } catch (...) {
45060       {
45061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45062       };
45063     }
45064   }
45065 }
45066
45067
45068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
45069   void * jresult ;
45070   Dali::Vector< float > *arg1 = 0 ;
45071   Dali::Vector< float > *result = 0 ;
45072
45073   arg1 = (Dali::Vector< float > *)jarg1;
45074   if (!arg1) {
45075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45076     return 0;
45077   }
45078   {
45079     try {
45080       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
45081     } catch (std::out_of_range& e) {
45082       {
45083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45084       };
45085     } catch (std::exception& e) {
45086       {
45087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45088       };
45089     } catch (...) {
45090       {
45091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45092       };
45093     }
45094   }
45095   jresult = (void *)result;
45096   return jresult;
45097 }
45098
45099
45100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
45101   void * jresult ;
45102   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45103   Dali::Vector< float > *arg2 = 0 ;
45104   Dali::Vector< float > *result = 0 ;
45105
45106   arg1 = (Dali::Vector< float > *)jarg1;
45107   arg2 = (Dali::Vector< float > *)jarg2;
45108   if (!arg2) {
45109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
45110     return 0;
45111   }
45112   {
45113     try {
45114       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45122       };
45123     } catch (...) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45126       };
45127     }
45128   }
45129   jresult = (void *)result;
45130   return jresult;
45131 }
45132
45133
45134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
45135   void * jresult ;
45136   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45137   Dali::Vector< float >::Iterator result;
45138
45139   arg1 = (Dali::Vector< float > *)jarg1;
45140   {
45141     try {
45142       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
45143     } catch (std::out_of_range& e) {
45144       {
45145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45146       };
45147     } catch (std::exception& e) {
45148       {
45149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45150       };
45151     } catch (...) {
45152       {
45153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45154       };
45155     }
45156   }
45157   jresult = (void *)result;
45158   return jresult;
45159 }
45160
45161
45162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
45163   void * jresult ;
45164   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45165   Dali::Vector< float >::Iterator result;
45166
45167   arg1 = (Dali::Vector< float > *)jarg1;
45168   {
45169     try {
45170       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
45171     } catch (std::out_of_range& e) {
45172       {
45173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45174       };
45175     } catch (std::exception& e) {
45176       {
45177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45178       };
45179     } catch (...) {
45180       {
45181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45182       };
45183     }
45184   }
45185   jresult = (void *)result;
45186   return jresult;
45187 }
45188
45189
45190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45191   void * jresult ;
45192   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45193   Dali::Vector< float >::SizeType arg2 ;
45194   Dali::Vector< float >::ItemType *result = 0 ;
45195
45196   arg1 = (Dali::Vector< float > *)jarg1;
45197   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45198   {
45199     try {
45200       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
45201     } catch (std::out_of_range& e) {
45202       {
45203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45204       };
45205     } catch (std::exception& e) {
45206       {
45207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45212       };
45213     }
45214   }
45215   jresult = (void *)result;
45216   return jresult;
45217 }
45218
45219
45220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
45221   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45222   Dali::Vector< float >::ItemType *arg2 = 0 ;
45223   Dali::Vector< float >::ItemType temp2 ;
45224
45225   arg1 = (Dali::Vector< float > *)jarg1;
45226   temp2 = (Dali::Vector< float >::ItemType)jarg2;
45227   arg2 = &temp2;
45228   {
45229     try {
45230       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
45231     } catch (std::out_of_range& e) {
45232       {
45233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45234       };
45235     } catch (std::exception& e) {
45236       {
45237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45238       };
45239     } catch (...) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45242       };
45243     }
45244   }
45245 }
45246
45247
45248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
45249   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45250   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45251   Dali::Vector< float >::ItemType *arg3 = 0 ;
45252   Dali::Vector< float >::ItemType temp3 ;
45253
45254   arg1 = (Dali::Vector< float > *)jarg1;
45255   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45256   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45257   arg3 = &temp3;
45258   {
45259     try {
45260       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45261     } catch (std::out_of_range& e) {
45262       {
45263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45264       };
45265     } catch (std::exception& e) {
45266       {
45267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45268       };
45269     } catch (...) {
45270       {
45271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45272       };
45273     }
45274   }
45275 }
45276
45277
45278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45279   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45280   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45281   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45282   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
45283
45284   arg1 = (Dali::Vector< float > *)jarg1;
45285   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45286   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45287   arg4 = (Dali::Vector< float >::Iterator)jarg4;
45288   {
45289     try {
45290       (arg1)->Insert(arg2,arg3,arg4);
45291     } catch (std::out_of_range& e) {
45292       {
45293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45294       };
45295     } catch (std::exception& e) {
45296       {
45297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45298       };
45299     } catch (...) {
45300       {
45301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45302       };
45303     }
45304   }
45305 }
45306
45307
45308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
45309   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45310   Dali::Vector< float >::SizeType arg2 ;
45311
45312   arg1 = (Dali::Vector< float > *)jarg1;
45313   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45314   {
45315     try {
45316       (arg1)->Reserve(arg2);
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45324       };
45325     } catch (...) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45328       };
45329     }
45330   }
45331 }
45332
45333
45334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45335   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45336   Dali::Vector< float >::SizeType arg2 ;
45337
45338   arg1 = (Dali::Vector< float > *)jarg1;
45339   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45340   {
45341     try {
45342       (arg1)->Resize(arg2);
45343     } catch (std::out_of_range& e) {
45344       {
45345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45346       };
45347     } catch (std::exception& e) {
45348       {
45349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45350       };
45351     } catch (...) {
45352       {
45353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45354       };
45355     }
45356   }
45357 }
45358
45359
45360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
45361   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45362   Dali::Vector< float >::SizeType arg2 ;
45363   Dali::Vector< float >::ItemType *arg3 = 0 ;
45364   Dali::Vector< float >::ItemType temp3 ;
45365
45366   arg1 = (Dali::Vector< float > *)jarg1;
45367   arg2 = (Dali::Vector< float >::SizeType)jarg2;
45368   temp3 = (Dali::Vector< float >::ItemType)jarg3;
45369   arg3 = &temp3;
45370   {
45371     try {
45372       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
45373     } catch (std::out_of_range& e) {
45374       {
45375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45376       };
45377     } catch (std::exception& e) {
45378       {
45379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45380       };
45381     } catch (...) {
45382       {
45383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45384       };
45385     }
45386   }
45387 }
45388
45389
45390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
45391   void * jresult ;
45392   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45393   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45394   Dali::Vector< float >::Iterator result;
45395
45396   arg1 = (Dali::Vector< float > *)jarg1;
45397   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45398   {
45399     try {
45400       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
45401     } catch (std::out_of_range& e) {
45402       {
45403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (std::exception& e) {
45406       {
45407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (...) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45412       };
45413     }
45414   }
45415   jresult = (void *)result;
45416   return jresult;
45417 }
45418
45419
45420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
45421   void * jresult ;
45422   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45423   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45424   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
45425   Dali::Vector< float >::Iterator result;
45426
45427   arg1 = (Dali::Vector< float > *)jarg1;
45428   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45429   arg3 = (Dali::Vector< float >::Iterator)jarg3;
45430   {
45431     try {
45432       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
45433     } catch (std::out_of_range& e) {
45434       {
45435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (std::exception& e) {
45438       {
45439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447   jresult = (void *)result;
45448   return jresult;
45449 }
45450
45451
45452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
45453   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45454   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
45455
45456   arg1 = (Dali::Vector< float > *)jarg1;
45457   arg2 = (Dali::Vector< float >::Iterator)jarg2;
45458   {
45459     try {
45460       (arg1)->Remove(arg2);
45461     } catch (std::out_of_range& e) {
45462       {
45463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45464       };
45465     } catch (std::exception& e) {
45466       {
45467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45468       };
45469     } catch (...) {
45470       {
45471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45472       };
45473     }
45474   }
45475 }
45476
45477
45478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
45479   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45480   Dali::Vector< float > *arg2 = 0 ;
45481
45482   arg1 = (Dali::Vector< float > *)jarg1;
45483   arg2 = (Dali::Vector< float > *)jarg2;
45484   if (!arg2) {
45485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
45486     return ;
45487   }
45488   {
45489     try {
45490       (arg1)->Swap(*arg2);
45491     } catch (std::out_of_range& e) {
45492       {
45493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45494       };
45495     } catch (std::exception& e) {
45496       {
45497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45498       };
45499     } catch (...) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45502       };
45503     }
45504   }
45505 }
45506
45507
45508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
45509   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45510
45511   arg1 = (Dali::Vector< float > *)jarg1;
45512   {
45513     try {
45514       (arg1)->Clear();
45515     } catch (std::out_of_range& e) {
45516       {
45517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45518       };
45519     } catch (std::exception& e) {
45520       {
45521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45522       };
45523     } catch (...) {
45524       {
45525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45526       };
45527     }
45528   }
45529 }
45530
45531
45532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
45533   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
45534
45535   arg1 = (Dali::Vector< float > *)jarg1;
45536   {
45537     try {
45538       (arg1)->Release();
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45546       };
45547     } catch (...) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45550       };
45551     }
45552   }
45553 }
45554
45555
45556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
45557   int jresult ;
45558   int result;
45559
45560   result = (int)Dali::Vector< unsigned char >::BaseType;
45561   jresult = (int)result;
45562   return jresult;
45563 }
45564
45565
45566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
45567   void * jresult ;
45568   Dali::Vector< unsigned char > *result = 0 ;
45569
45570   {
45571     try {
45572       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
45573     } catch (std::out_of_range& e) {
45574       {
45575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45576       };
45577     } catch (std::exception& e) {
45578       {
45579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45580       };
45581     } catch (...) {
45582       {
45583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45584       };
45585     }
45586   }
45587   jresult = (void *)result;
45588   return jresult;
45589 }
45590
45591
45592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
45593   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45594
45595   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45596   {
45597     try {
45598       delete arg1;
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45606       };
45607     } catch (...) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45610       };
45611     }
45612   }
45613 }
45614
45615
45616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
45617   void * jresult ;
45618   Dali::Vector< unsigned char > *arg1 = 0 ;
45619   Dali::Vector< unsigned char > *result = 0 ;
45620
45621   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45622   if (!arg1) {
45623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45624     return 0;
45625   }
45626   {
45627     try {
45628       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
45629     } catch (std::out_of_range& e) {
45630       {
45631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45632       };
45633     } catch (std::exception& e) {
45634       {
45635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45636       };
45637     } catch (...) {
45638       {
45639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45640       };
45641     }
45642   }
45643   jresult = (void *)result;
45644   return jresult;
45645 }
45646
45647
45648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
45649   void * jresult ;
45650   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45651   Dali::Vector< unsigned char > *arg2 = 0 ;
45652   Dali::Vector< unsigned char > *result = 0 ;
45653
45654   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45655   arg2 = (Dali::Vector< unsigned char > *)jarg2;
45656   if (!arg2) {
45657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
45658     return 0;
45659   }
45660   {
45661     try {
45662       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
45663     } catch (std::out_of_range& e) {
45664       {
45665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45666       };
45667     } catch (std::exception& e) {
45668       {
45669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45670       };
45671     } catch (...) {
45672       {
45673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45674       };
45675     }
45676   }
45677   jresult = (void *)result;
45678   return jresult;
45679 }
45680
45681
45682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
45683   void * jresult ;
45684   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45685   Dali::Vector< unsigned char >::Iterator result;
45686
45687   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45688   {
45689     try {
45690       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
45691     } catch (std::out_of_range& e) {
45692       {
45693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45694       };
45695     } catch (std::exception& e) {
45696       {
45697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45698       };
45699     } catch (...) {
45700       {
45701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45702       };
45703     }
45704   }
45705   jresult = (void *)result;
45706   return jresult;
45707 }
45708
45709
45710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
45711   void * jresult ;
45712   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45713   Dali::Vector< unsigned char >::Iterator result;
45714
45715   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45716   {
45717     try {
45718       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
45719     } catch (std::out_of_range& e) {
45720       {
45721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45722       };
45723     } catch (std::exception& e) {
45724       {
45725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45726       };
45727     } catch (...) {
45728       {
45729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45730       };
45731     }
45732   }
45733   jresult = (void *)result;
45734   return jresult;
45735 }
45736
45737
45738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
45739   void * jresult ;
45740   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45741   Dali::Vector< unsigned char >::SizeType arg2 ;
45742   Dali::Vector< unsigned char >::ItemType *result = 0 ;
45743
45744   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45745   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45746   {
45747     try {
45748       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
45749     } catch (std::out_of_range& e) {
45750       {
45751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45752       };
45753     } catch (std::exception& e) {
45754       {
45755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45756       };
45757     } catch (...) {
45758       {
45759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45760       };
45761     }
45762   }
45763   jresult = (void *)result;
45764   return jresult;
45765 }
45766
45767
45768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
45769   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45770   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
45771   Dali::Vector< unsigned char >::ItemType temp2 ;
45772
45773   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45774   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
45775   arg2 = &temp2;
45776   {
45777     try {
45778       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
45779     } catch (std::out_of_range& e) {
45780       {
45781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45782       };
45783     } catch (std::exception& e) {
45784       {
45785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45786       };
45787     } catch (...) {
45788       {
45789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45790       };
45791     }
45792   }
45793 }
45794
45795
45796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
45797   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45798   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45799   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45800   Dali::Vector< unsigned char >::ItemType temp3 ;
45801
45802   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45803   arg2 = jarg2;
45804   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45805   arg3 = &temp3;
45806   {
45807     try {
45808       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45809     } catch (std::out_of_range& e) {
45810       {
45811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45812       };
45813     } catch (std::exception& e) {
45814       {
45815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45816       };
45817     } catch (...) {
45818       {
45819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45820       };
45821     }
45822   }
45823
45824
45825 }
45826
45827
45828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
45829   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45830   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45831   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45832   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45833
45834   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45835   arg2 = jarg2;
45836   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45837   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
45838   {
45839     try {
45840       (arg1)->Insert(arg2,arg3,arg4);
45841     } catch (std::out_of_range& e) {
45842       {
45843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45844       };
45845     } catch (std::exception& e) {
45846       {
45847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45848       };
45849     } catch (...) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45852       };
45853     }
45854   }
45855
45856
45857 }
45858
45859
45860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
45861   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45862   Dali::Vector< unsigned char >::SizeType arg2 ;
45863
45864   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45865   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45866   {
45867     try {
45868       (arg1)->Reserve(arg2);
45869     } catch (std::out_of_range& e) {
45870       {
45871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45872       };
45873     } catch (std::exception& e) {
45874       {
45875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45876       };
45877     } catch (...) {
45878       {
45879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45880       };
45881     }
45882   }
45883 }
45884
45885
45886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
45887   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45888   Dali::Vector< unsigned char >::SizeType arg2 ;
45889
45890   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45891   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45892   {
45893     try {
45894       (arg1)->Resize(arg2);
45895     } catch (std::out_of_range& e) {
45896       {
45897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45898       };
45899     } catch (std::exception& e) {
45900       {
45901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45902       };
45903     } catch (...) {
45904       {
45905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45906       };
45907     }
45908   }
45909 }
45910
45911
45912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
45913   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45914   Dali::Vector< unsigned char >::SizeType arg2 ;
45915   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
45916   Dali::Vector< unsigned char >::ItemType temp3 ;
45917
45918   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45919   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
45920   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
45921   arg3 = &temp3;
45922   {
45923     try {
45924       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
45925     } catch (std::out_of_range& e) {
45926       {
45927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45928       };
45929     } catch (std::exception& e) {
45930       {
45931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45932       };
45933     } catch (...) {
45934       {
45935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45936       };
45937     }
45938   }
45939 }
45940
45941
45942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
45943   void * jresult ;
45944   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45945   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45946   Dali::Vector< unsigned char >::Iterator result;
45947
45948   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45949   arg2 = jarg2;
45950   {
45951     try {
45952       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
45953     } catch (std::out_of_range& e) {
45954       {
45955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45956       };
45957     } catch (std::exception& e) {
45958       {
45959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45960       };
45961     } catch (...) {
45962       {
45963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45964       };
45965     }
45966   }
45967   jresult = (void *)result;
45968
45969
45970   return jresult;
45971 }
45972
45973
45974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
45975   void * jresult ;
45976   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
45977   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45978   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
45979   Dali::Vector< unsigned char >::Iterator result;
45980
45981   arg1 = (Dali::Vector< unsigned char > *)jarg1;
45982   arg2 = jarg2;
45983   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
45984   {
45985     try {
45986       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
45987     } catch (std::out_of_range& e) {
45988       {
45989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45990       };
45991     } catch (std::exception& e) {
45992       {
45993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45994       };
45995     } catch (...) {
45996       {
45997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45998       };
45999     }
46000   }
46001   jresult = (void *)result;
46002
46003
46004   return jresult;
46005 }
46006
46007
46008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
46009   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46010   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
46011
46012   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46013   arg2 = jarg2;
46014   {
46015     try {
46016       (arg1)->Remove(arg2);
46017     } catch (std::out_of_range& e) {
46018       {
46019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46020       };
46021     } catch (std::exception& e) {
46022       {
46023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46024       };
46025     } catch (...) {
46026       {
46027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46028       };
46029     }
46030   }
46031
46032
46033 }
46034
46035
46036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
46037   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46038   Dali::Vector< unsigned char > *arg2 = 0 ;
46039
46040   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46041   arg2 = (Dali::Vector< unsigned char > *)jarg2;
46042   if (!arg2) {
46043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
46044     return ;
46045   }
46046   {
46047     try {
46048       (arg1)->Swap(*arg2);
46049     } catch (std::out_of_range& e) {
46050       {
46051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46052       };
46053     } catch (std::exception& e) {
46054       {
46055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46056       };
46057     } catch (...) {
46058       {
46059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46060       };
46061     }
46062   }
46063 }
46064
46065
46066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
46067   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46068
46069   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46070   {
46071     try {
46072       (arg1)->Clear();
46073     } catch (std::out_of_range& e) {
46074       {
46075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46076       };
46077     } catch (std::exception& e) {
46078       {
46079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46080       };
46081     } catch (...) {
46082       {
46083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46084       };
46085     }
46086   }
46087 }
46088
46089
46090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
46091   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
46092
46093   arg1 = (Dali::Vector< unsigned char > *)jarg1;
46094   {
46095     try {
46096       (arg1)->Release();
46097     } catch (std::out_of_range& e) {
46098       {
46099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46100       };
46101     } catch (std::exception& e) {
46102       {
46103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46104       };
46105     } catch (...) {
46106       {
46107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46108       };
46109     }
46110   }
46111 }
46112
46113
46114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
46115   int jresult ;
46116   int result;
46117
46118   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
46119   jresult = (int)result;
46120   return jresult;
46121 }
46122
46123
46124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
46125   void * jresult ;
46126   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46127
46128   {
46129     try {
46130       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
46131     } catch (std::out_of_range& e) {
46132       {
46133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46134       };
46135     } catch (std::exception& e) {
46136       {
46137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46138       };
46139     } catch (...) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46142       };
46143     }
46144   }
46145   jresult = (void *)result;
46146   return jresult;
46147 }
46148
46149
46150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
46151   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46152
46153   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46154   {
46155     try {
46156       delete arg1;
46157     } catch (std::out_of_range& e) {
46158       {
46159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46160       };
46161     } catch (std::exception& e) {
46162       {
46163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46164       };
46165     } catch (...) {
46166       {
46167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46168       };
46169     }
46170   }
46171 }
46172
46173
46174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
46175   void * jresult ;
46176   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
46177   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46178
46179   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46180   if (!arg1) {
46181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46182     return 0;
46183   }
46184   {
46185     try {
46186       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
46187     } catch (std::out_of_range& e) {
46188       {
46189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46190       };
46191     } catch (std::exception& e) {
46192       {
46193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46194       };
46195     } catch (...) {
46196       {
46197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46198       };
46199     }
46200   }
46201   jresult = (void *)result;
46202   return jresult;
46203 }
46204
46205
46206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
46207   void * jresult ;
46208   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46209   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46210   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
46211
46212   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46213   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46214   if (!arg2) {
46215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
46216     return 0;
46217   }
46218   {
46219     try {
46220       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
46221     } catch (std::out_of_range& e) {
46222       {
46223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46224       };
46225     } catch (std::exception& e) {
46226       {
46227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46228       };
46229     } catch (...) {
46230       {
46231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46232       };
46233     }
46234   }
46235   jresult = (void *)result;
46236   return jresult;
46237 }
46238
46239
46240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
46241   void * jresult ;
46242   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46243   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46244
46245   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46246   {
46247     try {
46248       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
46249     } catch (std::out_of_range& e) {
46250       {
46251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (std::exception& e) {
46254       {
46255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46256       };
46257     } catch (...) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46260       };
46261     }
46262   }
46263   jresult = (void *)result;
46264   return jresult;
46265 }
46266
46267
46268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
46269   void * jresult ;
46270   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46271   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46272
46273   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46274   {
46275     try {
46276       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
46277     } catch (std::out_of_range& e) {
46278       {
46279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46280       };
46281     } catch (std::exception& e) {
46282       {
46283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46284       };
46285     } catch (...) {
46286       {
46287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46288       };
46289     }
46290   }
46291   jresult = (void *)result;
46292   return jresult;
46293 }
46294
46295
46296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46297   void * jresult ;
46298   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46299   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46300   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
46301
46302   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46303   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46304   {
46305     try {
46306       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
46307     } catch (std::out_of_range& e) {
46308       {
46309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (std::exception& e) {
46312       {
46313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (...) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46318       };
46319     }
46320   }
46321   jresult = (void *)result;
46322   return jresult;
46323 }
46324
46325
46326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
46327   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46328   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
46329
46330   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46331   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
46332   if (!arg2) {
46333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46334     return ;
46335   }
46336   {
46337     try {
46338       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
46339     } catch (std::out_of_range& e) {
46340       {
46341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46342       };
46343     } catch (std::exception& e) {
46344       {
46345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46346       };
46347     } catch (...) {
46348       {
46349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46350       };
46351     }
46352   }
46353 }
46354
46355
46356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
46357   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46358   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46359   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46360
46361   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46362   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46363   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46364   if (!arg3) {
46365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46366     return ;
46367   }
46368   {
46369     try {
46370       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46371     } catch (std::out_of_range& e) {
46372       {
46373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46374       };
46375     } catch (std::exception& e) {
46376       {
46377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46378       };
46379     } catch (...) {
46380       {
46381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46382       };
46383     }
46384   }
46385 }
46386
46387
46388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46389   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46390   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46391   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46392   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46393
46394   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46395   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46396   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46397   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
46398   {
46399     try {
46400       (arg1)->Insert(arg2,arg3,arg4);
46401     } catch (std::out_of_range& e) {
46402       {
46403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46404       };
46405     } catch (std::exception& e) {
46406       {
46407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46408       };
46409     } catch (...) {
46410       {
46411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46412       };
46413     }
46414   }
46415 }
46416
46417
46418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
46419   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46420   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46421
46422   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46423   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46424   {
46425     try {
46426       (arg1)->Reserve(arg2);
46427     } catch (std::out_of_range& e) {
46428       {
46429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46430       };
46431     } catch (std::exception& e) {
46432       {
46433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46434       };
46435     } catch (...) {
46436       {
46437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46438       };
46439     }
46440   }
46441 }
46442
46443
46444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46445   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46446   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46447
46448   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46449   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46450   {
46451     try {
46452       (arg1)->Resize(arg2);
46453     } catch (std::out_of_range& e) {
46454       {
46455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46456       };
46457     } catch (std::exception& e) {
46458       {
46459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46460       };
46461     } catch (...) {
46462       {
46463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46464       };
46465     }
46466   }
46467 }
46468
46469
46470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
46471   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46472   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
46473   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
46474
46475   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46476   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
46477   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
46478   if (!arg3) {
46479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
46480     return ;
46481   }
46482   {
46483     try {
46484       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
46485     } catch (std::out_of_range& e) {
46486       {
46487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46488       };
46489     } catch (std::exception& e) {
46490       {
46491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46492       };
46493     } catch (...) {
46494       {
46495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46496       };
46497     }
46498   }
46499 }
46500
46501
46502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
46503   void * jresult ;
46504   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46505   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46506   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46507
46508   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46509   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46510   {
46511     try {
46512       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
46513     } catch (std::out_of_range& e) {
46514       {
46515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46516       };
46517     } catch (std::exception& e) {
46518       {
46519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46520       };
46521     } catch (...) {
46522       {
46523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46524       };
46525     }
46526   }
46527   jresult = (void *)result;
46528   return jresult;
46529 }
46530
46531
46532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46533   void * jresult ;
46534   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46535   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46536   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46537   Dali::Vector< Dali::Uint16Pair >::Iterator result;
46538
46539   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46540   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46541   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
46542   {
46543     try {
46544       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
46545     } catch (std::out_of_range& e) {
46546       {
46547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46548       };
46549     } catch (std::exception& e) {
46550       {
46551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46552       };
46553     } catch (...) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46556       };
46557     }
46558   }
46559   jresult = (void *)result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
46565   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46566   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
46567
46568   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46569   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
46570   {
46571     try {
46572       (arg1)->Remove(arg2);
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46580       };
46581     } catch (...) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46584       };
46585     }
46586   }
46587 }
46588
46589
46590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
46591   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46592   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
46593
46594   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46595   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
46596   if (!arg2) {
46597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
46598     return ;
46599   }
46600   {
46601     try {
46602       (arg1)->Swap(*arg2);
46603     } catch (std::out_of_range& e) {
46604       {
46605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46606       };
46607     } catch (std::exception& e) {
46608       {
46609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46610       };
46611     } catch (...) {
46612       {
46613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46614       };
46615     }
46616   }
46617 }
46618
46619
46620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
46621   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46622
46623   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46624   {
46625     try {
46626       (arg1)->Clear();
46627     } catch (std::out_of_range& e) {
46628       {
46629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46630       };
46631     } catch (std::exception& e) {
46632       {
46633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46638       };
46639     }
46640   }
46641 }
46642
46643
46644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
46645   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
46646
46647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
46648   {
46649     try {
46650       (arg1)->Release();
46651     } catch (std::out_of_range& e) {
46652       {
46653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46654       };
46655     } catch (std::exception& e) {
46656       {
46657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46658       };
46659     } catch (...) {
46660       {
46661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46662       };
46663     }
46664   }
46665 }
46666
46667
46668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
46669   void * jresult ;
46670   Dali::Signal< void () > *result = 0 ;
46671
46672   {
46673     try {
46674       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
46675     } catch (std::out_of_range& e) {
46676       {
46677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46678       };
46679     } catch (std::exception& e) {
46680       {
46681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46682       };
46683     } catch (...) {
46684       {
46685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46686       };
46687     }
46688   }
46689   jresult = (void *)result;
46690   return jresult;
46691 }
46692
46693
46694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
46695   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46696
46697   arg1 = (Dali::Signal< void () > *)jarg1;
46698   {
46699     try {
46700       delete arg1;
46701     } catch (std::out_of_range& e) {
46702       {
46703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46704       };
46705     } catch (std::exception& e) {
46706       {
46707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46708       };
46709     } catch (...) {
46710       {
46711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46712       };
46713     }
46714   }
46715 }
46716
46717
46718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
46719   unsigned int jresult ;
46720   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46721   bool result;
46722
46723   arg1 = (Dali::Signal< void () > *)jarg1;
46724   {
46725     try {
46726       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
46727     } catch (std::out_of_range& e) {
46728       {
46729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46730       };
46731     } catch (std::exception& e) {
46732       {
46733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46734       };
46735     } catch (...) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46738       };
46739     }
46740   }
46741   jresult = result;
46742   return jresult;
46743 }
46744
46745
46746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
46747   unsigned long jresult ;
46748   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46749   std::size_t result;
46750
46751   arg1 = (Dali::Signal< void () > *)jarg1;
46752   {
46753     try {
46754       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
46755     } catch (std::out_of_range& e) {
46756       {
46757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46758       };
46759     } catch (std::exception& e) {
46760       {
46761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46762       };
46763     } catch (...) {
46764       {
46765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46766       };
46767     }
46768   }
46769   jresult = (unsigned long)result;
46770   return jresult;
46771 }
46772
46773
46774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
46775   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46776   void (*arg2)() = (void (*)()) 0 ;
46777
46778   arg1 = (Dali::Signal< void () > *)jarg1;
46779   arg2 = (void (*)())jarg2;
46780   {
46781     try {
46782       (arg1)->Connect(arg2);
46783     } catch (std::out_of_range& e) {
46784       {
46785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46786       };
46787     } catch (std::exception& e) {
46788       {
46789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46794       };
46795     }
46796   }
46797 }
46798
46799
46800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
46801   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46802   void (*arg2)() = (void (*)()) 0 ;
46803
46804   arg1 = (Dali::Signal< void () > *)jarg1;
46805   arg2 = (void (*)())jarg2;
46806   {
46807     try {
46808       (arg1)->Disconnect(arg2);
46809     } catch (std::out_of_range& e) {
46810       {
46811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46812       };
46813     } catch (std::exception& e) {
46814       {
46815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46816       };
46817     } catch (...) {
46818       {
46819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46820       };
46821     }
46822   }
46823 }
46824
46825
46826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
46827   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46828   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
46829   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
46830
46831   arg1 = (Dali::Signal< void () > *)jarg1;
46832   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
46833   arg3 = (Dali::FunctorDelegate *)jarg3;
46834   {
46835     try {
46836       (arg1)->Connect(arg2,arg3);
46837     } catch (std::out_of_range& e) {
46838       {
46839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46840       };
46841     } catch (std::exception& e) {
46842       {
46843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46844       };
46845     } catch (...) {
46846       {
46847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46848       };
46849     }
46850   }
46851 }
46852
46853
46854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
46855   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
46856
46857   arg1 = (Dali::Signal< void () > *)jarg1;
46858   {
46859     try {
46860       (arg1)->Emit();
46861     } catch (std::out_of_range& e) {
46862       {
46863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46864       };
46865     } catch (std::exception& e) {
46866       {
46867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46868       };
46869     } catch (...) {
46870       {
46871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46872       };
46873     }
46874   }
46875 }
46876
46877
46878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
46879   unsigned int jresult ;
46880   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46881   bool result;
46882
46883   arg1 = (Dali::Signal< void (float) > *)jarg1;
46884   {
46885     try {
46886       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
46887     } catch (std::out_of_range& e) {
46888       {
46889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46890       };
46891     } catch (std::exception& e) {
46892       {
46893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46894       };
46895     } catch (...) {
46896       {
46897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46898       };
46899     }
46900   }
46901   jresult = result;
46902   return jresult;
46903 }
46904
46905
46906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
46907   unsigned long jresult ;
46908   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46909   std::size_t result;
46910
46911   arg1 = (Dali::Signal< void (float) > *)jarg1;
46912   {
46913     try {
46914       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
46915     } catch (std::out_of_range& e) {
46916       {
46917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46918       };
46919     } catch (std::exception& e) {
46920       {
46921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46922       };
46923     } catch (...) {
46924       {
46925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46926       };
46927     }
46928   }
46929   jresult = (unsigned long)result;
46930   return jresult;
46931 }
46932
46933
46934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
46935   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46936   void (*arg2)(float) = (void (*)(float)) 0 ;
46937
46938   arg1 = (Dali::Signal< void (float) > *)jarg1;
46939   arg2 = (void (*)(float))jarg2;
46940   {
46941     try {
46942       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
46943     } catch (std::out_of_range& e) {
46944       {
46945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46946       };
46947     } catch (std::exception& e) {
46948       {
46949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46950       };
46951     } catch (...) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46954       };
46955     }
46956   }
46957 }
46958
46959
46960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
46961   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46962   void (*arg2)(float) = (void (*)(float)) 0 ;
46963
46964   arg1 = (Dali::Signal< void (float) > *)jarg1;
46965   arg2 = (void (*)(float))jarg2;
46966   {
46967     try {
46968       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
46969     } catch (std::out_of_range& e) {
46970       {
46971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46972       };
46973     } catch (std::exception& e) {
46974       {
46975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46976       };
46977     } catch (...) {
46978       {
46979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46980       };
46981     }
46982   }
46983 }
46984
46985
46986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
46987   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
46988   float arg2 ;
46989
46990   arg1 = (Dali::Signal< void (float) > *)jarg1;
46991   arg2 = (float)jarg2;
46992   {
46993     try {
46994       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
46995     } catch (std::out_of_range& e) {
46996       {
46997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46998       };
46999     } catch (std::exception& e) {
47000       {
47001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47002       };
47003     } catch (...) {
47004       {
47005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47006       };
47007     }
47008   }
47009 }
47010
47011
47012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
47013   void * jresult ;
47014   Dali::Signal< void (float) > *result = 0 ;
47015
47016   {
47017     try {
47018       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
47019     } catch (std::out_of_range& e) {
47020       {
47021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47022       };
47023     } catch (std::exception& e) {
47024       {
47025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47026       };
47027     } catch (...) {
47028       {
47029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47030       };
47031     }
47032   }
47033   jresult = (void *)result;
47034   return jresult;
47035 }
47036
47037
47038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
47039   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
47040
47041   arg1 = (Dali::Signal< void (float) > *)jarg1;
47042   {
47043     try {
47044       delete arg1;
47045     } catch (std::out_of_range& e) {
47046       {
47047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47048       };
47049     } catch (std::exception& e) {
47050       {
47051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47052       };
47053     } catch (...) {
47054       {
47055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47056       };
47057     }
47058   }
47059 }
47060
47061
47062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
47063   unsigned int jresult ;
47064   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47065   bool result;
47066
47067   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47068   {
47069     try {
47070       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47071     } catch (std::out_of_range& e) {
47072       {
47073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (std::exception& e) {
47076       {
47077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (...) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47082       };
47083     }
47084   }
47085   jresult = result;
47086   return jresult;
47087 }
47088
47089
47090 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
47091   unsigned long jresult ;
47092   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47093   std::size_t result;
47094
47095   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47096   {
47097     try {
47098       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
47099     } catch (std::out_of_range& e) {
47100       {
47101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47102       };
47103     } catch (std::exception& e) {
47104       {
47105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47106       };
47107     } catch (...) {
47108       {
47109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47110       };
47111     }
47112   }
47113   jresult = (unsigned long)result;
47114   return jresult;
47115 }
47116
47117
47118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
47119   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47120   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47121
47122   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47123   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47124   {
47125     try {
47126       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
47127     } catch (std::out_of_range& e) {
47128       {
47129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47130       };
47131     } catch (std::exception& e) {
47132       {
47133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47134       };
47135     } catch (...) {
47136       {
47137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47138       };
47139     }
47140   }
47141 }
47142
47143
47144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
47145   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47146   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
47147
47148   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47149   arg2 = (void (*)(Dali::BaseHandle))jarg2;
47150   {
47151     try {
47152       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
47153     } catch (std::out_of_range& e) {
47154       {
47155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47156       };
47157     } catch (std::exception& e) {
47158       {
47159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47160       };
47161     } catch (...) {
47162       {
47163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47164       };
47165     }
47166   }
47167 }
47168
47169
47170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
47171   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47172   Dali::BaseHandle arg2 ;
47173   Dali::BaseHandle *argp2 ;
47174
47175   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47176   argp2 = (Dali::BaseHandle *)jarg2;
47177   if (!argp2) {
47178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47179     return ;
47180   }
47181   arg2 = *argp2;
47182   {
47183     try {
47184       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
47185     } catch (std::out_of_range& e) {
47186       {
47187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47188       };
47189     } catch (std::exception& e) {
47190       {
47191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47192       };
47193     } catch (...) {
47194       {
47195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47196       };
47197     }
47198   }
47199 }
47200
47201
47202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
47203   void * jresult ;
47204   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
47205
47206   {
47207     try {
47208       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (...) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47220       };
47221     }
47222   }
47223   jresult = (void *)result;
47224   return jresult;
47225 }
47226
47227
47228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
47229   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
47230
47231   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
47232   {
47233     try {
47234       delete arg1;
47235     } catch (std::out_of_range& e) {
47236       {
47237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47238       };
47239     } catch (std::exception& e) {
47240       {
47241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47242       };
47243     } catch (...) {
47244       {
47245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47246       };
47247     }
47248   }
47249 }
47250
47251
47252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
47253   unsigned int jresult ;
47254   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47255   bool result;
47256
47257   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47258   {
47259     try {
47260       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47261     } catch (std::out_of_range& e) {
47262       {
47263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47264       };
47265     } catch (std::exception& e) {
47266       {
47267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (...) {
47270       {
47271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47272       };
47273     }
47274   }
47275   jresult = result;
47276   return jresult;
47277 }
47278
47279
47280 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
47281   unsigned long jresult ;
47282   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47283   std::size_t result;
47284
47285   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47286   {
47287     try {
47288       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
47289     } catch (std::out_of_range& e) {
47290       {
47291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47292       };
47293     } catch (std::exception& e) {
47294       {
47295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (...) {
47298       {
47299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47300       };
47301     }
47302   }
47303   jresult = (unsigned long)result;
47304   return jresult;
47305 }
47306
47307
47308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
47309   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47310   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47311
47312   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47313   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47314   {
47315     try {
47316       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
47317     } catch (std::out_of_range& e) {
47318       {
47319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47320       };
47321     } catch (std::exception& e) {
47322       {
47323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47324       };
47325     } catch (...) {
47326       {
47327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47328       };
47329     }
47330   }
47331 }
47332
47333
47334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
47335   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47336   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
47337
47338   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47339   arg2 = (void (*)(Dali::RefObject const *))jarg2;
47340   {
47341     try {
47342       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
47343     } catch (std::out_of_range& e) {
47344       {
47345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47346       };
47347     } catch (std::exception& e) {
47348       {
47349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47350       };
47351     } catch (...) {
47352       {
47353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47354       };
47355     }
47356   }
47357 }
47358
47359
47360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
47361   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47362   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
47363
47364   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47365   arg2 = (Dali::RefObject *)jarg2;
47366   {
47367     try {
47368       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
47369     } catch (std::out_of_range& e) {
47370       {
47371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47372       };
47373     } catch (std::exception& e) {
47374       {
47375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47376       };
47377     } catch (...) {
47378       {
47379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47380       };
47381     }
47382   }
47383 }
47384
47385
47386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
47387   void * jresult ;
47388   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
47389
47390   {
47391     try {
47392       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
47393     } catch (std::out_of_range& e) {
47394       {
47395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47396       };
47397     } catch (std::exception& e) {
47398       {
47399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47400       };
47401     } catch (...) {
47402       {
47403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47404       };
47405     }
47406   }
47407   jresult = (void *)result;
47408   return jresult;
47409 }
47410
47411
47412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
47413   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
47414
47415   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
47416   {
47417     try {
47418       delete arg1;
47419     } catch (std::out_of_range& e) {
47420       {
47421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47422       };
47423     } catch (std::exception& e) {
47424       {
47425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47426       };
47427     } catch (...) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47430       };
47431     }
47432   }
47433 }
47434
47435
47436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
47437   unsigned int jresult ;
47438   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47439   bool result;
47440
47441   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47442   {
47443     try {
47444       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47445     } catch (std::out_of_range& e) {
47446       {
47447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47448       };
47449     } catch (std::exception& e) {
47450       {
47451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47452       };
47453     } catch (...) {
47454       {
47455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47456       };
47457     }
47458   }
47459   jresult = result;
47460   return jresult;
47461 }
47462
47463
47464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
47465   unsigned long jresult ;
47466   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47467   std::size_t result;
47468
47469   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47470   {
47471     try {
47472       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
47473     } catch (std::out_of_range& e) {
47474       {
47475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47476       };
47477     } catch (std::exception& e) {
47478       {
47479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47480       };
47481     } catch (...) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47484       };
47485     }
47486   }
47487   jresult = (unsigned long)result;
47488   return jresult;
47489 }
47490
47491
47492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
47493   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47494   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47495
47496   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47497   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47498   {
47499     try {
47500       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
47501     } catch (std::out_of_range& e) {
47502       {
47503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47504       };
47505     } catch (std::exception& e) {
47506       {
47507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47508       };
47509     } catch (...) {
47510       {
47511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47512       };
47513     }
47514   }
47515 }
47516
47517
47518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
47519   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47520   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
47521
47522   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47523   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
47524   {
47525     try {
47526       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
47527     } catch (std::out_of_range& e) {
47528       {
47529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47530       };
47531     } catch (std::exception& e) {
47532       {
47533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47534       };
47535     } catch (...) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47538       };
47539     }
47540   }
47541 }
47542
47543
47544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
47545   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47546   Dali::PropertyNotification *arg2 = 0 ;
47547
47548   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47549   arg2 = (Dali::PropertyNotification *)jarg2;
47550   if (!arg2) {
47551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
47552     return ;
47553   }
47554   {
47555     try {
47556       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
47557     } catch (std::out_of_range& e) {
47558       {
47559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47560       };
47561     } catch (std::exception& e) {
47562       {
47563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47564       };
47565     } catch (...) {
47566       {
47567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47568       };
47569     }
47570   }
47571 }
47572
47573
47574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
47575   void * jresult ;
47576   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
47577
47578   {
47579     try {
47580       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
47581     } catch (std::out_of_range& e) {
47582       {
47583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47584       };
47585     } catch (std::exception& e) {
47586       {
47587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47588       };
47589     } catch (...) {
47590       {
47591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47592       };
47593     }
47594   }
47595   jresult = (void *)result;
47596   return jresult;
47597 }
47598
47599
47600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
47601   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
47602
47603   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
47604   {
47605     try {
47606       delete arg1;
47607     } catch (std::out_of_range& e) {
47608       {
47609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47610       };
47611     } catch (std::exception& e) {
47612       {
47613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47614       };
47615     } catch (...) {
47616       {
47617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47618       };
47619     }
47620   }
47621 }
47622
47623
47624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
47625   unsigned int jresult ;
47626   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47627   bool result;
47628
47629   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47630   {
47631     try {
47632       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
47633     } catch (std::out_of_range& e) {
47634       {
47635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47636       };
47637     } catch (std::exception& e) {
47638       {
47639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47640       };
47641     } catch (...) {
47642       {
47643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47644       };
47645     }
47646   }
47647   jresult = result;
47648   return jresult;
47649 }
47650
47651
47652 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
47653   unsigned long jresult ;
47654   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47655   std::size_t result;
47656
47657   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47658   {
47659     try {
47660       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
47661     } catch (std::out_of_range& e) {
47662       {
47663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47664       };
47665     } catch (std::exception& e) {
47666       {
47667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (...) {
47670       {
47671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47672       };
47673     }
47674   }
47675   jresult = (unsigned long)result;
47676   return jresult;
47677 }
47678
47679
47680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
47681   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47682   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47683
47684   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47685   arg2 = (void (*)(Dali::Image))jarg2;
47686   {
47687     try {
47688       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
47689     } catch (std::out_of_range& e) {
47690       {
47691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47692       };
47693     } catch (std::exception& e) {
47694       {
47695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47696       };
47697     } catch (...) {
47698       {
47699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47700       };
47701     }
47702   }
47703 }
47704
47705
47706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
47707   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47708   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
47709
47710   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47711   arg2 = (void (*)(Dali::Image))jarg2;
47712   {
47713     try {
47714       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
47715     } catch (std::out_of_range& e) {
47716       {
47717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47718       };
47719     } catch (std::exception& e) {
47720       {
47721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47722       };
47723     } catch (...) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47726       };
47727     }
47728   }
47729 }
47730
47731
47732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
47733   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47734   Dali::Image arg2 ;
47735   Dali::Image *argp2 ;
47736
47737   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47738   argp2 = (Dali::Image *)jarg2;
47739   if (!argp2) {
47740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
47741     return ;
47742   }
47743   arg2 = *argp2;
47744   {
47745     try {
47746       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
47747     } catch (std::out_of_range& e) {
47748       {
47749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47750       };
47751     } catch (std::exception& e) {
47752       {
47753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47754       };
47755     } catch (...) {
47756       {
47757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47758       };
47759     }
47760   }
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
47765   void * jresult ;
47766   Dali::Signal< void (Dali::Image) > *result = 0 ;
47767
47768   {
47769     try {
47770       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
47771     } catch (std::out_of_range& e) {
47772       {
47773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47774       };
47775     } catch (std::exception& e) {
47776       {
47777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47778       };
47779     } catch (...) {
47780       {
47781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47782       };
47783     }
47784   }
47785   jresult = (void *)result;
47786   return jresult;
47787 }
47788
47789
47790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
47791   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
47792
47793   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
47794   {
47795     try {
47796       delete arg1;
47797     } catch (std::out_of_range& e) {
47798       {
47799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47800       };
47801     } catch (std::exception& e) {
47802       {
47803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47804       };
47805     } catch (...) {
47806       {
47807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47808       };
47809     }
47810   }
47811 }
47812
47813
47814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
47815   void * jresult ;
47816   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
47817
47818   {
47819     try {
47820       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
47821     } catch (std::out_of_range& e) {
47822       {
47823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47824       };
47825     } catch (std::exception& e) {
47826       {
47827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47828       };
47829     } catch (...) {
47830       {
47831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47832       };
47833     }
47834   }
47835   jresult = (void *)result;
47836   return jresult;
47837 }
47838
47839
47840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
47841   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
47842
47843   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
47844   {
47845     try {
47846       delete arg1;
47847     } catch (std::out_of_range& e) {
47848       {
47849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47850       };
47851     } catch (std::exception& e) {
47852       {
47853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47858       };
47859     }
47860   }
47861 }
47862
47863
47864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
47865   unsigned int jresult ;
47866   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47867   bool result;
47868
47869   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47870   {
47871     try {
47872       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);
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (...) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47884       };
47885     }
47886   }
47887   jresult = result;
47888   return jresult;
47889 }
47890
47891
47892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
47893   unsigned long jresult ;
47894   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47895   std::size_t result;
47896
47897   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47898   {
47899     try {
47900       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);
47901     } catch (std::out_of_range& e) {
47902       {
47903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47904       };
47905     } catch (std::exception& e) {
47906       {
47907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47908       };
47909     } catch (...) {
47910       {
47911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47912       };
47913     }
47914   }
47915   jresult = (unsigned long)result;
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
47921   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47922   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47923
47924   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47925   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47926   {
47927     try {
47928       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
47929     } catch (std::out_of_range& e) {
47930       {
47931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47932       };
47933     } catch (std::exception& e) {
47934       {
47935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47940       };
47941     }
47942   }
47943 }
47944
47945
47946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
47947   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47948   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
47949
47950   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47951   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
47952   {
47953     try {
47954       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
47955     } catch (std::out_of_range& e) {
47956       {
47957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47958       };
47959     } catch (std::exception& e) {
47960       {
47961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47962       };
47963     } catch (...) {
47964       {
47965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47966       };
47967     }
47968   }
47969 }
47970
47971
47972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
47973   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
47974   Dali::Actor arg2 ;
47975   Dali::LongPressGesture *arg3 = 0 ;
47976   Dali::Actor *argp2 ;
47977
47978   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
47979   argp2 = (Dali::Actor *)jarg2;
47980   if (!argp2) {
47981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47982     return ;
47983   }
47984   arg2 = *argp2;
47985   arg3 = (Dali::LongPressGesture *)jarg3;
47986   if (!arg3) {
47987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
47988     return ;
47989   }
47990   {
47991     try {
47992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
47993     } catch (std::out_of_range& e) {
47994       {
47995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47996       };
47997     } catch (std::exception& e) {
47998       {
47999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48000       };
48001     } catch (...) {
48002       {
48003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48004       };
48005     }
48006   }
48007 }
48008
48009
48010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
48011   void * jresult ;
48012   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
48013
48014   {
48015     try {
48016       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
48017     } catch (std::out_of_range& e) {
48018       {
48019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48020       };
48021     } catch (std::exception& e) {
48022       {
48023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48024       };
48025     } catch (...) {
48026       {
48027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48028       };
48029     }
48030   }
48031   jresult = (void *)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
48037   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
48038
48039   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
48040   {
48041     try {
48042       delete arg1;
48043     } catch (std::out_of_range& e) {
48044       {
48045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48046       };
48047     } catch (std::exception& e) {
48048       {
48049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48050       };
48051     } catch (...) {
48052       {
48053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48054       };
48055     }
48056   }
48057 }
48058
48059
48060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
48061   unsigned int jresult ;
48062   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48063   bool result;
48064
48065   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48066   {
48067     try {
48068       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);
48069     } catch (std::out_of_range& e) {
48070       {
48071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48072       };
48073     } catch (std::exception& e) {
48074       {
48075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48076       };
48077     } catch (...) {
48078       {
48079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48080       };
48081     }
48082   }
48083   jresult = result;
48084   return jresult;
48085 }
48086
48087
48088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
48089   unsigned long jresult ;
48090   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48091   std::size_t result;
48092
48093   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48094   {
48095     try {
48096       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);
48097     } catch (std::out_of_range& e) {
48098       {
48099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48100       };
48101     } catch (std::exception& e) {
48102       {
48103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48104       };
48105     } catch (...) {
48106       {
48107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48108       };
48109     }
48110   }
48111   jresult = (unsigned long)result;
48112   return jresult;
48113 }
48114
48115
48116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
48117   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48118   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48119
48120   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48121   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48122   {
48123     try {
48124       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48125     } catch (std::out_of_range& e) {
48126       {
48127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48128       };
48129     } catch (std::exception& e) {
48130       {
48131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48132       };
48133     } catch (...) {
48134       {
48135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48136       };
48137     }
48138   }
48139 }
48140
48141
48142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
48143   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48144   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
48145
48146   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48147   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
48148   {
48149     try {
48150       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48151     } catch (std::out_of_range& e) {
48152       {
48153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48154       };
48155     } catch (std::exception& e) {
48156       {
48157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48158       };
48159     } catch (...) {
48160       {
48161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48162       };
48163     }
48164   }
48165 }
48166
48167
48168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48169   unsigned int jresult ;
48170   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48171   Dali::Actor arg2 ;
48172   Dali::TouchData *arg3 = 0 ;
48173   Dali::Actor *argp2 ;
48174   bool result;
48175
48176   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48177   argp2 = (Dali::Actor *)jarg2;
48178   if (!argp2) {
48179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48180     return 0;
48181   }
48182   arg2 = *argp2;
48183   arg3 = (Dali::TouchData *)jarg3;
48184   if (!arg3) {
48185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
48186     return 0;
48187   }
48188   {
48189     try {
48190       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
48191     } catch (std::out_of_range& e) {
48192       {
48193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48194       };
48195     } catch (std::exception& e) {
48196       {
48197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48198       };
48199     } catch (...) {
48200       {
48201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48202       };
48203     }
48204   }
48205   jresult = result;
48206   return jresult;
48207 }
48208
48209
48210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
48211   void * jresult ;
48212   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
48213
48214   {
48215     try {
48216       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
48217     } catch (std::out_of_range& e) {
48218       {
48219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48220       };
48221     } catch (std::exception& e) {
48222       {
48223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48224       };
48225     } catch (...) {
48226       {
48227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48228       };
48229     }
48230   }
48231   jresult = (void *)result;
48232   return jresult;
48233 }
48234
48235
48236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
48237   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
48238
48239   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
48240   {
48241     try {
48242       delete arg1;
48243     } catch (std::out_of_range& e) {
48244       {
48245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48246       };
48247     } catch (std::exception& e) {
48248       {
48249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48250       };
48251     } catch (...) {
48252       {
48253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48254       };
48255     }
48256   }
48257 }
48258
48259
48260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
48261   unsigned int jresult ;
48262   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48263   bool result;
48264
48265   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48266   {
48267     try {
48268       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);
48269     } catch (std::out_of_range& e) {
48270       {
48271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48272       };
48273     } catch (std::exception& e) {
48274       {
48275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48276       };
48277     } catch (...) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48280       };
48281     }
48282   }
48283   jresult = result;
48284   return jresult;
48285 }
48286
48287
48288 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
48289   unsigned long jresult ;
48290   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48291   std::size_t result;
48292
48293   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48294   {
48295     try {
48296       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);
48297     } catch (std::out_of_range& e) {
48298       {
48299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48300       };
48301     } catch (std::exception& e) {
48302       {
48303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48304       };
48305     } catch (...) {
48306       {
48307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48308       };
48309     }
48310   }
48311   jresult = (unsigned long)result;
48312   return jresult;
48313 }
48314
48315
48316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
48317   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48318   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48319
48320   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48321   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48322   {
48323     try {
48324       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48325     } catch (std::out_of_range& e) {
48326       {
48327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48328       };
48329     } catch (std::exception& e) {
48330       {
48331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48332       };
48333     } catch (...) {
48334       {
48335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48336       };
48337     }
48338   }
48339 }
48340
48341
48342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
48343   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48344   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
48345
48346   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48347   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
48348   {
48349     try {
48350       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48351     } catch (std::out_of_range& e) {
48352       {
48353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48354       };
48355     } catch (std::exception& e) {
48356       {
48357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48358       };
48359     } catch (...) {
48360       {
48361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48362       };
48363     }
48364   }
48365 }
48366
48367
48368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48369   unsigned int jresult ;
48370   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48371   Dali::Actor arg2 ;
48372   Dali::HoverEvent *arg3 = 0 ;
48373   Dali::Actor *argp2 ;
48374   bool result;
48375
48376   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48377   argp2 = (Dali::Actor *)jarg2;
48378   if (!argp2) {
48379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48380     return 0;
48381   }
48382   arg2 = *argp2;
48383   arg3 = (Dali::HoverEvent *)jarg3;
48384   if (!arg3) {
48385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
48386     return 0;
48387   }
48388   {
48389     try {
48390       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
48391     } catch (std::out_of_range& e) {
48392       {
48393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48394       };
48395     } catch (std::exception& e) {
48396       {
48397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48398       };
48399     } catch (...) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48402       };
48403     }
48404   }
48405   jresult = result;
48406   return jresult;
48407 }
48408
48409
48410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
48411   void * jresult ;
48412   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
48413
48414   {
48415     try {
48416       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
48417     } catch (std::out_of_range& e) {
48418       {
48419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48420       };
48421     } catch (std::exception& e) {
48422       {
48423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48424       };
48425     } catch (...) {
48426       {
48427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48428       };
48429     }
48430   }
48431   jresult = (void *)result;
48432   return jresult;
48433 }
48434
48435
48436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
48437   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
48438
48439   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
48440   {
48441     try {
48442       delete arg1;
48443     } catch (std::out_of_range& e) {
48444       {
48445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48446       };
48447     } catch (std::exception& e) {
48448       {
48449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48450       };
48451     } catch (...) {
48452       {
48453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48454       };
48455     }
48456   }
48457 }
48458
48459
48460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
48461   unsigned int jresult ;
48462   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48463   bool result;
48464
48465   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48466   {
48467     try {
48468       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);
48469     } catch (std::out_of_range& e) {
48470       {
48471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48472       };
48473     } catch (std::exception& e) {
48474       {
48475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48476       };
48477     } catch (...) {
48478       {
48479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48480       };
48481     }
48482   }
48483   jresult = result;
48484   return jresult;
48485 }
48486
48487
48488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
48489   unsigned long jresult ;
48490   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48491   std::size_t result;
48492
48493   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48494   {
48495     try {
48496       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);
48497     } catch (std::out_of_range& e) {
48498       {
48499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48500       };
48501     } catch (std::exception& e) {
48502       {
48503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48504       };
48505     } catch (...) {
48506       {
48507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48508       };
48509     }
48510   }
48511   jresult = (unsigned long)result;
48512   return jresult;
48513 }
48514
48515
48516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
48517   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48518   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48519
48520   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48521   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48522   {
48523     try {
48524       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48525     } catch (std::out_of_range& e) {
48526       {
48527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (std::exception& e) {
48530       {
48531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539 }
48540
48541
48542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
48543   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48544   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
48545
48546   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48547   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
48548   {
48549     try {
48550       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48551     } catch (std::out_of_range& e) {
48552       {
48553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48554       };
48555     } catch (std::exception& e) {
48556       {
48557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (...) {
48560       {
48561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48562       };
48563     }
48564   }
48565 }
48566
48567
48568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
48569   unsigned int jresult ;
48570   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48571   Dali::Actor arg2 ;
48572   Dali::WheelEvent *arg3 = 0 ;
48573   Dali::Actor *argp2 ;
48574   bool result;
48575
48576   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48577   argp2 = (Dali::Actor *)jarg2;
48578   if (!argp2) {
48579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48580     return 0;
48581   }
48582   arg2 = *argp2;
48583   arg3 = (Dali::WheelEvent *)jarg3;
48584   if (!arg3) {
48585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
48586     return 0;
48587   }
48588   {
48589     try {
48590       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
48591     } catch (std::out_of_range& e) {
48592       {
48593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48594       };
48595     } catch (std::exception& e) {
48596       {
48597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48598       };
48599     } catch (...) {
48600       {
48601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48602       };
48603     }
48604   }
48605   jresult = result;
48606   return jresult;
48607 }
48608
48609
48610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
48611   void * jresult ;
48612   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
48613
48614   {
48615     try {
48616       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
48617     } catch (std::out_of_range& e) {
48618       {
48619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48620       };
48621     } catch (std::exception& e) {
48622       {
48623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48624       };
48625     } catch (...) {
48626       {
48627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48628       };
48629     }
48630   }
48631   jresult = (void *)result;
48632   return jresult;
48633 }
48634
48635
48636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
48637   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
48638
48639   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
48640   {
48641     try {
48642       delete arg1;
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48650       };
48651     } catch (...) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48654       };
48655     }
48656   }
48657 }
48658
48659
48660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
48661   unsigned int jresult ;
48662   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48663   bool result;
48664
48665   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48666   {
48667     try {
48668       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
48669     } catch (std::out_of_range& e) {
48670       {
48671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48672       };
48673     } catch (std::exception& e) {
48674       {
48675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48676       };
48677     } catch (...) {
48678       {
48679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48680       };
48681     }
48682   }
48683   jresult = result;
48684   return jresult;
48685 }
48686
48687
48688 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
48689   unsigned long jresult ;
48690   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48691   std::size_t result;
48692
48693   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48694   {
48695     try {
48696       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
48697     } catch (std::out_of_range& e) {
48698       {
48699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48700       };
48701     } catch (std::exception& e) {
48702       {
48703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48704       };
48705     } catch (...) {
48706       {
48707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48708       };
48709     }
48710   }
48711   jresult = (unsigned long)result;
48712   return jresult;
48713 }
48714
48715
48716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
48717   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48718   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48719
48720   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48721   arg2 = (void (*)(Dali::Actor))jarg2;
48722   {
48723     try {
48724       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
48725     } catch (std::out_of_range& e) {
48726       {
48727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48728       };
48729     } catch (std::exception& e) {
48730       {
48731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48732       };
48733     } catch (...) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48736       };
48737     }
48738   }
48739 }
48740
48741
48742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
48743   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48744   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
48745
48746   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48747   arg2 = (void (*)(Dali::Actor))jarg2;
48748   {
48749     try {
48750       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
48751     } catch (std::out_of_range& e) {
48752       {
48753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48754       };
48755     } catch (std::exception& e) {
48756       {
48757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48758       };
48759     } catch (...) {
48760       {
48761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48762       };
48763     }
48764   }
48765 }
48766
48767
48768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
48769   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48770   Dali::Actor arg2 ;
48771   Dali::Actor *argp2 ;
48772
48773   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48774   argp2 = (Dali::Actor *)jarg2;
48775   if (!argp2) {
48776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
48777     return ;
48778   }
48779   arg2 = *argp2;
48780   {
48781     try {
48782       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
48783     } catch (std::out_of_range& e) {
48784       {
48785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48786       };
48787     } catch (std::exception& e) {
48788       {
48789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48790       };
48791     } catch (...) {
48792       {
48793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48794       };
48795     }
48796   }
48797 }
48798
48799
48800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
48801   void * jresult ;
48802   Dali::Signal< void (Dali::Actor) > *result = 0 ;
48803
48804   {
48805     try {
48806       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
48807     } catch (std::out_of_range& e) {
48808       {
48809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (std::exception& e) {
48812       {
48813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48814       };
48815     } catch (...) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48818       };
48819     }
48820   }
48821   jresult = (void *)result;
48822   return jresult;
48823 }
48824
48825
48826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
48827   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
48828
48829   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
48830   {
48831     try {
48832       delete arg1;
48833     } catch (std::out_of_range& e) {
48834       {
48835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (std::exception& e) {
48838       {
48839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48840       };
48841     } catch (...) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48844       };
48845     }
48846   }
48847 }
48848
48849
48850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
48851   unsigned int jresult ;
48852   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48853   bool result;
48854
48855   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48856   {
48857     try {
48858       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48859     } catch (std::out_of_range& e) {
48860       {
48861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48862       };
48863     } catch (std::exception& e) {
48864       {
48865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48866       };
48867     } catch (...) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48870       };
48871     }
48872   }
48873   jresult = result;
48874   return jresult;
48875 }
48876
48877
48878 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
48879   unsigned long jresult ;
48880   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48881   std::size_t result;
48882
48883   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48884   {
48885     try {
48886       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
48887     } catch (std::out_of_range& e) {
48888       {
48889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48890       };
48891     } catch (std::exception& e) {
48892       {
48893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48894       };
48895     } catch (...) {
48896       {
48897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48898       };
48899     }
48900   }
48901   jresult = (unsigned long)result;
48902   return jresult;
48903 }
48904
48905
48906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
48907   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48908   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48909
48910   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48911   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48912   {
48913     try {
48914       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
48915     } catch (std::out_of_range& e) {
48916       {
48917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (std::exception& e) {
48920       {
48921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48922       };
48923     } catch (...) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48926       };
48927     }
48928   }
48929 }
48930
48931
48932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
48933   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48934   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
48935
48936   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48937   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
48938   {
48939     try {
48940       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
48941     } catch (std::out_of_range& e) {
48942       {
48943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48944       };
48945     } catch (std::exception& e) {
48946       {
48947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48948       };
48949     } catch (...) {
48950       {
48951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48952       };
48953     }
48954   }
48955 }
48956
48957
48958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
48959   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
48960   Dali::KeyEvent *arg2 = 0 ;
48961
48962   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
48963   arg2 = (Dali::KeyEvent *)jarg2;
48964   if (!arg2) {
48965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
48966     return ;
48967   }
48968   {
48969     try {
48970       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
48971     } catch (std::out_of_range& e) {
48972       {
48973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48974       };
48975     } catch (std::exception& e) {
48976       {
48977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48978       };
48979     } catch (...) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48982       };
48983     }
48984   }
48985 }
48986
48987
48988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
48989   void * jresult ;
48990   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
48991
48992   {
48993     try {
48994       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
48995     } catch (std::out_of_range& e) {
48996       {
48997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48998       };
48999     } catch (std::exception& e) {
49000       {
49001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49002       };
49003     } catch (...) {
49004       {
49005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49006       };
49007     }
49008   }
49009   jresult = (void *)result;
49010   return jresult;
49011 }
49012
49013
49014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
49015   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
49016
49017   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
49018   {
49019     try {
49020       delete arg1;
49021     } catch (std::out_of_range& e) {
49022       {
49023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49024       };
49025     } catch (std::exception& e) {
49026       {
49027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49028       };
49029     } catch (...) {
49030       {
49031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49032       };
49033     }
49034   }
49035 }
49036
49037
49038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
49039   unsigned int jresult ;
49040   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49041   bool result;
49042
49043   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49044   {
49045     try {
49046       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49047     } catch (std::out_of_range& e) {
49048       {
49049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49050       };
49051     } catch (std::exception& e) {
49052       {
49053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49054       };
49055     } catch (...) {
49056       {
49057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49058       };
49059     }
49060   }
49061   jresult = result;
49062   return jresult;
49063 }
49064
49065
49066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
49067   unsigned long jresult ;
49068   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49069   std::size_t result;
49070
49071   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49072   {
49073     try {
49074       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
49075     } catch (std::out_of_range& e) {
49076       {
49077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49078       };
49079     } catch (std::exception& e) {
49080       {
49081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49082       };
49083     } catch (...) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49086       };
49087     }
49088   }
49089   jresult = (unsigned long)result;
49090   return jresult;
49091 }
49092
49093
49094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
49095   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49096   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49097
49098   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49099   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49100   {
49101     try {
49102       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49103     } catch (std::out_of_range& e) {
49104       {
49105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49106       };
49107     } catch (std::exception& e) {
49108       {
49109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49110       };
49111     } catch (...) {
49112       {
49113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49114       };
49115     }
49116   }
49117 }
49118
49119
49120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
49121   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49122   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
49123
49124   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49125   arg2 = (void (*)(Dali::TouchData const &))jarg2;
49126   {
49127     try {
49128       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49129     } catch (std::out_of_range& e) {
49130       {
49131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49132       };
49133     } catch (std::exception& e) {
49134       {
49135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49136       };
49137     } catch (...) {
49138       {
49139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49140       };
49141     }
49142   }
49143 }
49144
49145
49146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
49147   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49148   Dali::TouchData *arg2 = 0 ;
49149
49150   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49151   arg2 = (Dali::TouchData *)jarg2;
49152   if (!arg2) {
49153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
49154     return ;
49155   }
49156   {
49157     try {
49158       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
49159     } catch (std::out_of_range& e) {
49160       {
49161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49162       };
49163     } catch (std::exception& e) {
49164       {
49165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49166       };
49167     } catch (...) {
49168       {
49169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49170       };
49171     }
49172   }
49173 }
49174
49175
49176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
49177   void * jresult ;
49178   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
49179
49180   {
49181     try {
49182       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
49183     } catch (std::out_of_range& e) {
49184       {
49185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49186       };
49187     } catch (std::exception& e) {
49188       {
49189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49190       };
49191     } catch (...) {
49192       {
49193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49194       };
49195     }
49196   }
49197   jresult = (void *)result;
49198   return jresult;
49199 }
49200
49201
49202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
49203   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
49204
49205   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
49206   {
49207     try {
49208       delete arg1;
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223 }
49224
49225
49226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
49227   unsigned int jresult ;
49228   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49229   bool result;
49230
49231   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49232   {
49233     try {
49234       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49235     } catch (std::out_of_range& e) {
49236       {
49237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49238       };
49239     } catch (std::exception& e) {
49240       {
49241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49246       };
49247     }
49248   }
49249   jresult = result;
49250   return jresult;
49251 }
49252
49253
49254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
49255   unsigned long jresult ;
49256   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49257   std::size_t result;
49258
49259   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49260   {
49261     try {
49262       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
49263     } catch (std::out_of_range& e) {
49264       {
49265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49266       };
49267     } catch (std::exception& e) {
49268       {
49269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49270       };
49271     } catch (...) {
49272       {
49273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49274       };
49275     }
49276   }
49277   jresult = (unsigned long)result;
49278   return jresult;
49279 }
49280
49281
49282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
49283   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49284   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49285
49286   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49287   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49288   {
49289     try {
49290       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49291     } catch (std::out_of_range& e) {
49292       {
49293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49294       };
49295     } catch (std::exception& e) {
49296       {
49297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49298       };
49299     } catch (...) {
49300       {
49301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49302       };
49303     }
49304   }
49305 }
49306
49307
49308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
49309   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49310   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
49311
49312   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49313   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
49314   {
49315     try {
49316       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49317     } catch (std::out_of_range& e) {
49318       {
49319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49320       };
49321     } catch (std::exception& e) {
49322       {
49323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49324       };
49325     } catch (...) {
49326       {
49327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49328       };
49329     }
49330   }
49331 }
49332
49333
49334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
49335   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49336   Dali::WheelEvent *arg2 = 0 ;
49337
49338   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49339   arg2 = (Dali::WheelEvent *)jarg2;
49340   if (!arg2) {
49341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
49342     return ;
49343   }
49344   {
49345     try {
49346       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
49347     } catch (std::out_of_range& e) {
49348       {
49349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49350       };
49351     } catch (std::exception& e) {
49352       {
49353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49354       };
49355     } catch (...) {
49356       {
49357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49358       };
49359     }
49360   }
49361 }
49362
49363
49364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
49365   void * jresult ;
49366   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
49367
49368   {
49369     try {
49370       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
49371     } catch (std::out_of_range& e) {
49372       {
49373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49374       };
49375     } catch (std::exception& e) {
49376       {
49377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49378       };
49379     } catch (...) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49382       };
49383     }
49384   }
49385   jresult = (void *)result;
49386   return jresult;
49387 }
49388
49389
49390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
49391   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
49392
49393   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
49394   {
49395     try {
49396       delete arg1;
49397     } catch (std::out_of_range& e) {
49398       {
49399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (std::exception& e) {
49402       {
49403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49404       };
49405     } catch (...) {
49406       {
49407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49408       };
49409     }
49410   }
49411 }
49412
49413
49414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
49415   void * jresult ;
49416   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49417
49418   {
49419     try {
49420       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
49421     } catch (std::out_of_range& e) {
49422       {
49423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49424       };
49425     } catch (std::exception& e) {
49426       {
49427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49428       };
49429     } catch (...) {
49430       {
49431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49432       };
49433     }
49434   }
49435   jresult = (void *)result;
49436   return jresult;
49437 }
49438
49439
49440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
49441   void * jresult ;
49442   Dali::Radian arg1 ;
49443   Dali::Radian arg2 ;
49444   Dali::Radian *argp1 ;
49445   Dali::Radian *argp2 ;
49446   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49447
49448   argp1 = (Dali::Radian *)jarg1;
49449   if (!argp1) {
49450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49451     return 0;
49452   }
49453   arg1 = *argp1;
49454   argp2 = (Dali::Radian *)jarg2;
49455   if (!argp2) {
49456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
49457     return 0;
49458   }
49459   arg2 = *argp2;
49460   {
49461     try {
49462       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
49463     } catch (std::out_of_range& e) {
49464       {
49465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (std::exception& e) {
49468       {
49469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477   jresult = (void *)result;
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
49483   void * jresult ;
49484   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
49485   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
49486
49487   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49488   if (!arg1) {
49489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
49490     return 0;
49491   }
49492   {
49493     try {
49494       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
49495     } catch (std::out_of_range& e) {
49496       {
49497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49498       };
49499     } catch (std::exception& e) {
49500       {
49501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (...) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49506       };
49507     }
49508   }
49509   jresult = (void *)result;
49510   return jresult;
49511 }
49512
49513
49514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
49515   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49516   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49517
49518   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49519   arg2 = (Dali::Radian *)jarg2;
49520   if (arg1) (arg1)->first = *arg2;
49521 }
49522
49523
49524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
49525   void * jresult ;
49526   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49527   Dali::Radian *result = 0 ;
49528
49529   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49530   result = (Dali::Radian *)& ((arg1)->first);
49531   jresult = (void *)result;
49532   return jresult;
49533 }
49534
49535
49536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
49537   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49538   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
49539
49540   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49541   arg2 = (Dali::Radian *)jarg2;
49542   if (arg1) (arg1)->second = *arg2;
49543 }
49544
49545
49546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
49547   void * jresult ;
49548   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49549   Dali::Radian *result = 0 ;
49550
49551   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49552   result = (Dali::Radian *)& ((arg1)->second);
49553   jresult = (void *)result;
49554   return jresult;
49555 }
49556
49557
49558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
49559   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
49560
49561   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
49562   {
49563     try {
49564       delete arg1;
49565     } catch (std::out_of_range& e) {
49566       {
49567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49568       };
49569     } catch (std::exception& e) {
49570       {
49571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49572       };
49573     } catch (...) {
49574       {
49575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49576       };
49577     }
49578   }
49579 }
49580
49581
49582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
49583   unsigned int jresult ;
49584   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49585   bool result;
49586
49587   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49588   {
49589     try {
49590       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);
49591     } catch (std::out_of_range& e) {
49592       {
49593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49594       };
49595     } catch (std::exception& e) {
49596       {
49597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49598       };
49599     } catch (...) {
49600       {
49601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49602       };
49603     }
49604   }
49605   jresult = result;
49606   return jresult;
49607 }
49608
49609
49610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49611   unsigned long jresult ;
49612   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49613   std::size_t result;
49614
49615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49616   {
49617     try {
49618       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);
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (...) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49630       };
49631     }
49632   }
49633   jresult = (unsigned long)result;
49634   return jresult;
49635 }
49636
49637
49638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49639   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49640   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49641
49642   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49643   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49644   {
49645     try {
49646       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49647     } catch (std::out_of_range& e) {
49648       {
49649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49650       };
49651     } catch (std::exception& e) {
49652       {
49653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49654       };
49655     } catch (...) {
49656       {
49657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49658       };
49659     }
49660   }
49661 }
49662
49663
49664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49665   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49666   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
49667
49668   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49669   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
49670   {
49671     try {
49672       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49673     } catch (std::out_of_range& e) {
49674       {
49675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49676       };
49677     } catch (std::exception& e) {
49678       {
49679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (...) {
49682       {
49683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49684       };
49685     }
49686   }
49687 }
49688
49689
49690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49691   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49692   Dali::Actor arg2 ;
49693   Dali::PanGesture *arg3 = 0 ;
49694   Dali::Actor *argp2 ;
49695
49696   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49697   argp2 = (Dali::Actor *)jarg2;
49698   if (!argp2) {
49699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49700     return ;
49701   }
49702   arg2 = *argp2;
49703   arg3 = (Dali::PanGesture *)jarg3;
49704   if (!arg3) {
49705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
49706     return ;
49707   }
49708   {
49709     try {
49710       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
49711     } catch (std::out_of_range& e) {
49712       {
49713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49714       };
49715     } catch (std::exception& e) {
49716       {
49717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49718       };
49719     } catch (...) {
49720       {
49721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49722       };
49723     }
49724   }
49725 }
49726
49727
49728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
49729   void * jresult ;
49730   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
49731
49732   {
49733     try {
49734       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
49735     } catch (std::out_of_range& e) {
49736       {
49737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (std::exception& e) {
49740       {
49741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49742       };
49743     } catch (...) {
49744       {
49745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49746       };
49747     }
49748   }
49749   jresult = (void *)result;
49750   return jresult;
49751 }
49752
49753
49754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
49755   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
49756
49757   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
49758   {
49759     try {
49760       delete arg1;
49761     } catch (std::out_of_range& e) {
49762       {
49763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49764       };
49765     } catch (std::exception& e) {
49766       {
49767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (...) {
49770       {
49771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49772       };
49773     }
49774   }
49775 }
49776
49777
49778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
49779   unsigned int jresult ;
49780   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49781   bool result;
49782
49783   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49784   {
49785     try {
49786       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);
49787     } catch (std::out_of_range& e) {
49788       {
49789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (std::exception& e) {
49792       {
49793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49794       };
49795     } catch (...) {
49796       {
49797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49798       };
49799     }
49800   }
49801   jresult = result;
49802   return jresult;
49803 }
49804
49805
49806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49807   unsigned long jresult ;
49808   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49809   std::size_t result;
49810
49811   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49812   {
49813     try {
49814       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);
49815     } catch (std::out_of_range& e) {
49816       {
49817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49818       };
49819     } catch (std::exception& e) {
49820       {
49821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49822       };
49823     } catch (...) {
49824       {
49825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49826       };
49827     }
49828   }
49829   jresult = (unsigned long)result;
49830   return jresult;
49831 }
49832
49833
49834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49835   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49836   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49837
49838   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49839   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49840   {
49841     try {
49842       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49843     } catch (std::out_of_range& e) {
49844       {
49845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (std::exception& e) {
49848       {
49849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (...) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49854       };
49855     }
49856   }
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49861   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49862   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
49863
49864   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49865   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
49866   {
49867     try {
49868       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49869     } catch (std::out_of_range& e) {
49870       {
49871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (std::exception& e) {
49874       {
49875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49876       };
49877     } catch (...) {
49878       {
49879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49880       };
49881     }
49882   }
49883 }
49884
49885
49886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49887   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49888   Dali::Actor arg2 ;
49889   Dali::PinchGesture *arg3 = 0 ;
49890   Dali::Actor *argp2 ;
49891
49892   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49893   argp2 = (Dali::Actor *)jarg2;
49894   if (!argp2) {
49895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49896     return ;
49897   }
49898   arg2 = *argp2;
49899   arg3 = (Dali::PinchGesture *)jarg3;
49900   if (!arg3) {
49901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
49902     return ;
49903   }
49904   {
49905     try {
49906       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
49907     } catch (std::out_of_range& e) {
49908       {
49909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49910       };
49911     } catch (std::exception& e) {
49912       {
49913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49914       };
49915     } catch (...) {
49916       {
49917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49918       };
49919     }
49920   }
49921 }
49922
49923
49924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
49925   void * jresult ;
49926   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
49927
49928   {
49929     try {
49930       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
49931     } catch (std::out_of_range& e) {
49932       {
49933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49934       };
49935     } catch (std::exception& e) {
49936       {
49937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49938       };
49939     } catch (...) {
49940       {
49941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49942       };
49943     }
49944   }
49945   jresult = (void *)result;
49946   return jresult;
49947 }
49948
49949
49950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
49951   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
49952
49953   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
49954   {
49955     try {
49956       delete arg1;
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (...) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49968       };
49969     }
49970   }
49971 }
49972
49973
49974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
49975   unsigned int jresult ;
49976   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
49977   bool result;
49978
49979   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
49980   {
49981     try {
49982       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);
49983     } catch (std::out_of_range& e) {
49984       {
49985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49986       };
49987     } catch (std::exception& e) {
49988       {
49989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49990       };
49991     } catch (...) {
49992       {
49993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49994       };
49995     }
49996   }
49997   jresult = result;
49998   return jresult;
49999 }
50000
50001
50002 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
50003   unsigned long jresult ;
50004   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50005   std::size_t result;
50006
50007   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50008   {
50009     try {
50010       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);
50011     } catch (std::out_of_range& e) {
50012       {
50013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50014       };
50015     } catch (std::exception& e) {
50016       {
50017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50018       };
50019     } catch (...) {
50020       {
50021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50022       };
50023     }
50024   }
50025   jresult = (unsigned long)result;
50026   return jresult;
50027 }
50028
50029
50030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
50031   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50032   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50033
50034   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50035   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50036   {
50037     try {
50038       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50039     } catch (std::out_of_range& e) {
50040       {
50041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50042       };
50043     } catch (std::exception& e) {
50044       {
50045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50046       };
50047     } catch (...) {
50048       {
50049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50050       };
50051     }
50052   }
50053 }
50054
50055
50056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50057   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50058   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
50059
50060   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50061   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
50062   {
50063     try {
50064       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50065     } catch (std::out_of_range& e) {
50066       {
50067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50068       };
50069     } catch (std::exception& e) {
50070       {
50071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50072       };
50073     } catch (...) {
50074       {
50075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50076       };
50077     }
50078   }
50079 }
50080
50081
50082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50083   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50084   Dali::Actor arg2 ;
50085   Dali::TapGesture *arg3 = 0 ;
50086   Dali::Actor *argp2 ;
50087
50088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50089   argp2 = (Dali::Actor *)jarg2;
50090   if (!argp2) {
50091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50092     return ;
50093   }
50094   arg2 = *argp2;
50095   arg3 = (Dali::TapGesture *)jarg3;
50096   if (!arg3) {
50097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
50098     return ;
50099   }
50100   {
50101     try {
50102       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50110       };
50111     } catch (...) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50114       };
50115     }
50116   }
50117 }
50118
50119
50120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
50121   void * jresult ;
50122   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
50123
50124   {
50125     try {
50126       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
50127     } catch (std::out_of_range& e) {
50128       {
50129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (std::exception& e) {
50132       {
50133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50134       };
50135     } catch (...) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50138       };
50139     }
50140   }
50141   jresult = (void *)result;
50142   return jresult;
50143 }
50144
50145
50146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
50147   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
50148
50149   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
50150   {
50151     try {
50152       delete arg1;
50153     } catch (std::out_of_range& e) {
50154       {
50155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50156       };
50157     } catch (std::exception& e) {
50158       {
50159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50160       };
50161     } catch (...) {
50162       {
50163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50164       };
50165     }
50166   }
50167 }
50168
50169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
50170   unsigned int jresult ;
50171   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50172   bool result;
50173
50174   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50175   {
50176     try {
50177       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50178     } catch (std::out_of_range& e) {
50179       {
50180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50181       };
50182     } catch (std::exception& e) {
50183       {
50184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50185       };
50186     } catch (...) {
50187       {
50188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50189       };
50190     }
50191   }
50192   jresult = result;
50193   return jresult;
50194 }
50195
50196
50197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
50198   unsigned long jresult ;
50199   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50200   std::size_t result;
50201
50202   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50203   {
50204     try {
50205       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
50206     } catch (std::out_of_range& e) {
50207       {
50208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (std::exception& e) {
50211       {
50212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50213       };
50214     } catch (...) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50217       };
50218     }
50219   }
50220   jresult = (unsigned long)result;
50221   return jresult;
50222 }
50223
50224
50225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
50226   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50227   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50228
50229   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50230   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50231   {
50232     try {
50233       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
50234     } catch (std::out_of_range& e) {
50235       {
50236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50237       };
50238     } catch (std::exception& e) {
50239       {
50240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50241       };
50242     } catch (...) {
50243       {
50244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50245       };
50246     }
50247   }
50248 }
50249
50250
50251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
50252   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50253   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
50254
50255   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50256   arg2 = (void (*)(Dali::ResourceImage))jarg2;
50257   {
50258     try {
50259       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
50260     } catch (std::out_of_range& e) {
50261       {
50262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50263       };
50264     } catch (std::exception& e) {
50265       {
50266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50267       };
50268     } catch (...) {
50269       {
50270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50271       };
50272     }
50273   }
50274 }
50275
50276
50277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
50278   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50279   Dali::ResourceImage arg2 ;
50280   Dali::ResourceImage *argp2 ;
50281
50282   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50283   argp2 = (Dali::ResourceImage *)jarg2;
50284   if (!argp2) {
50285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
50286     return ;
50287   }
50288   arg2 = *argp2;
50289   {
50290     try {
50291       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
50292     } catch (std::out_of_range& e) {
50293       {
50294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50295       };
50296     } catch (std::exception& e) {
50297       {
50298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50299       };
50300     } catch (...) {
50301       {
50302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50303       };
50304     }
50305   }
50306 }
50307
50308
50309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
50310   void * jresult ;
50311   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
50312
50313   {
50314     try {
50315       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
50316     } catch (std::out_of_range& e) {
50317       {
50318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50319       };
50320     } catch (std::exception& e) {
50321       {
50322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50323       };
50324     } catch (...) {
50325       {
50326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50327       };
50328     }
50329   }
50330   jresult = (void *)result;
50331   return jresult;
50332 }
50333
50334
50335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
50336   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
50337
50338   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
50339   {
50340     try {
50341       delete arg1;
50342     } catch (std::out_of_range& e) {
50343       {
50344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50345       };
50346     } catch (std::exception& e) {
50347       {
50348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50349       };
50350     } catch (...) {
50351       {
50352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50353       };
50354     }
50355   }
50356 }
50357
50358
50359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
50360   unsigned int jresult ;
50361   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50362   bool result;
50363
50364   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50365   {
50366     try {
50367       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);
50368     } catch (std::out_of_range& e) {
50369       {
50370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50371       };
50372     } catch (std::exception& e) {
50373       {
50374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50375       };
50376     } catch (...) {
50377       {
50378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50379       };
50380     }
50381   }
50382   jresult = result;
50383   return jresult;
50384 }
50385
50386
50387 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
50388   unsigned long jresult ;
50389   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50390   std::size_t result;
50391
50392   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50393   {
50394     try {
50395       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);
50396     } catch (std::out_of_range& e) {
50397       {
50398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50399       };
50400     } catch (std::exception& e) {
50401       {
50402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50403       };
50404     } catch (...) {
50405       {
50406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50407       };
50408     }
50409   }
50410   jresult = (unsigned long)result;
50411   return jresult;
50412 }
50413
50414
50415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
50416   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50417   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50418
50419   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50420   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50421   {
50422     try {
50423       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
50424     } catch (std::out_of_range& e) {
50425       {
50426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50427       };
50428     } catch (std::exception& e) {
50429       {
50430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50431       };
50432     } catch (...) {
50433       {
50434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50435       };
50436     }
50437   }
50438 }
50439
50440
50441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
50442   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50443   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
50444
50445   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50446   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
50447   {
50448     try {
50449       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
50450     } catch (std::out_of_range& e) {
50451       {
50452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50453       };
50454     } catch (std::exception& e) {
50455       {
50456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50457       };
50458     } catch (...) {
50459       {
50460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50461       };
50462     }
50463   }
50464 }
50465
50466
50467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
50468   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50469   Dali::Actor arg2 ;
50470   bool arg3 ;
50471   Dali::DevelActor::VisibilityChange::Type arg4 ;
50472   Dali::Actor *argp2 ;
50473
50474   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50475   argp2 = (Dali::Actor *)jarg2;
50476   if (!argp2) {
50477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50478     return ;
50479   }
50480   arg2 = *argp2;
50481   arg3 = jarg3 ? true : false;
50482   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
50483   {
50484     try {
50485       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
50486     } catch (std::out_of_range& e) {
50487       {
50488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50489       };
50490     } catch (std::exception& e) {
50491       {
50492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50493       };
50494     } catch (...) {
50495       {
50496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50497       };
50498     }
50499   }
50500 }
50501
50502
50503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
50504   void * jresult ;
50505   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
50506
50507   {
50508     try {
50509       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
50510     } catch (std::out_of_range& e) {
50511       {
50512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50513       };
50514     } catch (std::exception& e) {
50515       {
50516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50517       };
50518     } catch (...) {
50519       {
50520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50521       };
50522     }
50523   }
50524   jresult = (void *)result;
50525   return jresult;
50526 }
50527
50528
50529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
50530   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
50531
50532   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
50533   {
50534     try {
50535       delete arg1;
50536     } catch (std::out_of_range& e) {
50537       {
50538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50539       };
50540     } catch (std::exception& e) {
50541       {
50542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50543       };
50544     } catch (...) {
50545       {
50546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50547       };
50548     }
50549   }
50550 }
50551
50552
50553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
50554   void * jresult ;
50555   Dali::Timer *result = 0 ;
50556
50557   {
50558     try {
50559       result = (Dali::Timer *)new Dali::Timer();
50560     } catch (std::out_of_range& e) {
50561       {
50562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50563       };
50564     } catch (std::exception& e) {
50565       {
50566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50567       };
50568     } catch (...) {
50569       {
50570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50571       };
50572     }
50573   }
50574   jresult = (void *)result;
50575   return jresult;
50576 }
50577
50578
50579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
50580   void * jresult ;
50581   unsigned int arg1 ;
50582   Dali::Timer result;
50583
50584   arg1 = (unsigned int)jarg1;
50585   {
50586     try {
50587       result = Dali::Timer::New(arg1);
50588     } catch (std::out_of_range& e) {
50589       {
50590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50591       };
50592     } catch (std::exception& e) {
50593       {
50594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50595       };
50596     } catch (...) {
50597       {
50598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50599       };
50600     }
50601   }
50602   jresult = new Dali::Timer((const Dali::Timer &)result);
50603   return jresult;
50604 }
50605
50606
50607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
50608   void * jresult ;
50609   Dali::Timer *arg1 = 0 ;
50610   Dali::Timer *result = 0 ;
50611
50612   arg1 = (Dali::Timer *)jarg1;
50613   if (!arg1) {
50614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50615     return 0;
50616   }
50617   {
50618     try {
50619       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
50620     } catch (std::out_of_range& e) {
50621       {
50622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50623       };
50624     } catch (std::exception& e) {
50625       {
50626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50627       };
50628     } catch (...) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50631       };
50632     }
50633   }
50634   jresult = (void *)result;
50635   return jresult;
50636 }
50637
50638
50639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
50640   void * jresult ;
50641   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50642   Dali::Timer *arg2 = 0 ;
50643   Dali::Timer *result = 0 ;
50644
50645   arg1 = (Dali::Timer *)jarg1;
50646   arg2 = (Dali::Timer *)jarg2;
50647   if (!arg2) {
50648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
50649     return 0;
50650   }
50651   {
50652     try {
50653       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
50654     } catch (std::out_of_range& e) {
50655       {
50656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50657       };
50658     } catch (std::exception& e) {
50659       {
50660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50661       };
50662     } catch (...) {
50663       {
50664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50665       };
50666     }
50667   }
50668   jresult = (void *)result;
50669   return jresult;
50670 }
50671
50672
50673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
50674   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50675
50676   arg1 = (Dali::Timer *)jarg1;
50677   {
50678     try {
50679       delete arg1;
50680     } catch (std::out_of_range& e) {
50681       {
50682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50683       };
50684     } catch (std::exception& e) {
50685       {
50686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50687       };
50688     } catch (...) {
50689       {
50690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50691       };
50692     }
50693   }
50694 }
50695
50696
50697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
50698   void * jresult ;
50699   Dali::BaseHandle arg1 ;
50700   Dali::BaseHandle *argp1 ;
50701   Dali::Timer result;
50702
50703   argp1 = (Dali::BaseHandle *)jarg1;
50704   if (!argp1) {
50705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50706     return 0;
50707   }
50708   arg1 = *argp1;
50709   {
50710     try {
50711       result = Dali::Timer::DownCast(arg1);
50712     } catch (std::out_of_range& e) {
50713       {
50714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50715       };
50716     } catch (std::exception& e) {
50717       {
50718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50719       };
50720     } catch (...) {
50721       {
50722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50723       };
50724     }
50725   }
50726   jresult = new Dali::Timer((const Dali::Timer &)result);
50727   return jresult;
50728 }
50729
50730
50731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
50732   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50733
50734   arg1 = (Dali::Timer *)jarg1;
50735   {
50736     try {
50737       (arg1)->Start();
50738     } catch (std::out_of_range& e) {
50739       {
50740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50741       };
50742     } catch (std::exception& e) {
50743       {
50744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50745       };
50746     } catch (...) {
50747       {
50748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50749       };
50750     }
50751   }
50752 }
50753
50754
50755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
50756   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50757
50758   arg1 = (Dali::Timer *)jarg1;
50759   {
50760     try {
50761       (arg1)->Stop();
50762     } catch (std::out_of_range& e) {
50763       {
50764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50765       };
50766     } catch (std::exception& e) {
50767       {
50768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50769       };
50770     } catch (...) {
50771       {
50772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50773       };
50774     }
50775   }
50776 }
50777
50778
50779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
50780   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50781   unsigned int arg2 ;
50782
50783   arg1 = (Dali::Timer *)jarg1;
50784   arg2 = (unsigned int)jarg2;
50785   {
50786     try {
50787       (arg1)->SetInterval(arg2);
50788     } catch (std::out_of_range& e) {
50789       {
50790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50791       };
50792     } catch (std::exception& e) {
50793       {
50794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50795       };
50796     } catch (...) {
50797       {
50798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50799       };
50800     }
50801   }
50802 }
50803
50804
50805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
50806   unsigned int jresult ;
50807   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50808   unsigned int result;
50809
50810   arg1 = (Dali::Timer *)jarg1;
50811   {
50812     try {
50813       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
50814     } catch (std::out_of_range& e) {
50815       {
50816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50817       };
50818     } catch (std::exception& e) {
50819       {
50820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50821       };
50822     } catch (...) {
50823       {
50824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50825       };
50826     }
50827   }
50828   jresult = result;
50829   return jresult;
50830 }
50831
50832
50833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
50834   unsigned int jresult ;
50835   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50836   bool result;
50837
50838   arg1 = (Dali::Timer *)jarg1;
50839   {
50840     try {
50841       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
50842     } catch (std::out_of_range& e) {
50843       {
50844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50845       };
50846     } catch (std::exception& e) {
50847       {
50848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50853       };
50854     }
50855   }
50856   jresult = result;
50857   return jresult;
50858 }
50859
50860
50861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
50862   void * jresult ;
50863   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
50864   Dali::Timer::TimerSignalType *result = 0 ;
50865
50866   arg1 = (Dali::Timer *)jarg1;
50867   {
50868     try {
50869       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
50870     } catch (std::out_of_range& e) {
50871       {
50872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50873       };
50874     } catch (std::exception& e) {
50875       {
50876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50877       };
50878     } catch (...) {
50879       {
50880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50881       };
50882     }
50883   }
50884   jresult = (void *)result;
50885   return jresult;
50886 }
50887
50888
50889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
50890   void * jresult ;
50891   Dali::DragAndDropDetector *result = 0 ;
50892
50893   {
50894     try {
50895       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
50896     } catch (std::out_of_range& e) {
50897       {
50898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50899       };
50900     } catch (std::exception& e) {
50901       {
50902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50903       };
50904     } catch (...) {
50905       {
50906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50907       };
50908     }
50909   }
50910   jresult = (void *)result;
50911   return jresult;
50912 }
50913
50914
50915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
50916   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50917
50918   arg1 = (Dali::DragAndDropDetector *)jarg1;
50919   {
50920     try {
50921       delete arg1;
50922     } catch (std::out_of_range& e) {
50923       {
50924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50925       };
50926     } catch (std::exception& e) {
50927       {
50928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50929       };
50930     } catch (...) {
50931       {
50932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50933       };
50934     }
50935   }
50936 }
50937
50938
50939 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
50940   char * jresult ;
50941   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50942   std::string *result = 0 ;
50943
50944   arg1 = (Dali::DragAndDropDetector *)jarg1;
50945   {
50946     try {
50947       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
50948     } catch (std::out_of_range& e) {
50949       {
50950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50951       };
50952     } catch (std::exception& e) {
50953       {
50954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50955       };
50956     } catch (...) {
50957       {
50958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50959       };
50960     }
50961   }
50962   jresult = SWIG_csharp_string_callback(result->c_str());
50963   return jresult;
50964 }
50965
50966
50967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
50968   void * jresult ;
50969   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50970   Dali::Vector2 result;
50971
50972   arg1 = (Dali::DragAndDropDetector *)jarg1;
50973   {
50974     try {
50975       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
50976     } catch (std::out_of_range& e) {
50977       {
50978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50979       };
50980     } catch (std::exception& e) {
50981       {
50982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50983       };
50984     } catch (...) {
50985       {
50986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50987       };
50988     }
50989   }
50990   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
50991   return jresult;
50992 }
50993
50994
50995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
50996   void * jresult ;
50997   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
50998   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
50999
51000   arg1 = (Dali::DragAndDropDetector *)jarg1;
51001   {
51002     try {
51003       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
51004     } catch (std::out_of_range& e) {
51005       {
51006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51007       };
51008     } catch (std::exception& e) {
51009       {
51010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51011       };
51012     } catch (...) {
51013       {
51014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51015       };
51016     }
51017   }
51018   jresult = (void *)result;
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
51024   void * jresult ;
51025   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51026   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51027
51028   arg1 = (Dali::DragAndDropDetector *)jarg1;
51029   {
51030     try {
51031       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
51032     } catch (std::out_of_range& e) {
51033       {
51034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51035       };
51036     } catch (std::exception& e) {
51037       {
51038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51039       };
51040     } catch (...) {
51041       {
51042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51043       };
51044     }
51045   }
51046   jresult = (void *)result;
51047   return jresult;
51048 }
51049
51050
51051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
51052   void * jresult ;
51053   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51054   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51055
51056   arg1 = (Dali::DragAndDropDetector *)jarg1;
51057   {
51058     try {
51059       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
51060     } catch (std::out_of_range& e) {
51061       {
51062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51063       };
51064     } catch (std::exception& e) {
51065       {
51066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51067       };
51068     } catch (...) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51071       };
51072     }
51073   }
51074   jresult = (void *)result;
51075   return jresult;
51076 }
51077
51078
51079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
51080   void * jresult ;
51081   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
51082   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
51083
51084   arg1 = (Dali::DragAndDropDetector *)jarg1;
51085   {
51086     try {
51087       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51095       };
51096     } catch (...) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51099       };
51100     }
51101   }
51102   jresult = (void *)result;
51103   return jresult;
51104 }
51105
51106
51107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
51108   void * jresult ;
51109   Dali::ApplicationExtensions *result = 0 ;
51110
51111   {
51112     try {
51113       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
51114     } catch (std::out_of_range& e) {
51115       {
51116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51117       };
51118     } catch (std::exception& e) {
51119       {
51120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51121       };
51122     } catch (...) {
51123       {
51124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51125       };
51126     }
51127   }
51128   jresult = (void *)result;
51129   return jresult;
51130 }
51131
51132
51133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
51134   void * jresult ;
51135   Dali::Application *arg1 = (Dali::Application *) 0 ;
51136   Dali::ApplicationExtensions *result = 0 ;
51137
51138   arg1 = (Dali::Application *)jarg1;
51139   {
51140     try {
51141       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
51142     } catch (std::out_of_range& e) {
51143       {
51144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51145       };
51146     } catch (std::exception& e) {
51147       {
51148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51149       };
51150     } catch (...) {
51151       {
51152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51153       };
51154     }
51155   }
51156   jresult = (void *)result;
51157   return jresult;
51158 }
51159
51160
51161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
51162   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51163
51164   arg1 = (Dali::ApplicationExtensions *)jarg1;
51165   {
51166     try {
51167       delete arg1;
51168     } catch (std::out_of_range& e) {
51169       {
51170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51171       };
51172     } catch (std::exception& e) {
51173       {
51174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51175       };
51176     } catch (...) {
51177       {
51178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51179       };
51180     }
51181   }
51182 }
51183
51184
51185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
51186   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51187
51188   arg1 = (Dali::ApplicationExtensions *)jarg1;
51189   {
51190     try {
51191       (arg1)->Init();
51192     } catch (std::out_of_range& e) {
51193       {
51194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51195       };
51196     } catch (std::exception& e) {
51197       {
51198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51199       };
51200     } catch (...) {
51201       {
51202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51203       };
51204     }
51205   }
51206 }
51207
51208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
51209   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51210
51211   arg1 = (Dali::ApplicationExtensions *)jarg1;
51212   {
51213     try {
51214       (arg1)->Start();
51215     } catch (std::out_of_range& e) {
51216       {
51217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51218       };
51219     } catch (std::exception& e) {
51220       {
51221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51222       };
51223     } catch (...) {
51224       {
51225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51226       };
51227     }
51228   }
51229 }
51230
51231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
51232   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51233
51234   arg1 = (Dali::ApplicationExtensions *)jarg1;
51235   {
51236     try {
51237       (arg1)->Terminate();
51238     } catch (std::out_of_range& e) {
51239       {
51240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51241       };
51242     } catch (std::exception& e) {
51243       {
51244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51245       };
51246     } catch (...) {
51247       {
51248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51249       };
51250     }
51251   }
51252 }
51253
51254
51255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
51256   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51257
51258   arg1 = (Dali::ApplicationExtensions *)jarg1;
51259   {
51260     try {
51261       (arg1)->Pause();
51262     } catch (std::out_of_range& e) {
51263       {
51264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51265       };
51266     } catch (std::exception& e) {
51267       {
51268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51269       };
51270     } catch (...) {
51271       {
51272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51273       };
51274     }
51275   }
51276 }
51277
51278
51279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
51280   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51281
51282   arg1 = (Dali::ApplicationExtensions *)jarg1;
51283   {
51284     try {
51285       (arg1)->Resume();
51286     } catch (std::out_of_range& e) {
51287       {
51288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51289       };
51290     } catch (std::exception& e) {
51291       {
51292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51293       };
51294     } catch (...) {
51295       {
51296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51297       };
51298     }
51299   }
51300 }
51301
51302
51303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
51304   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
51305
51306   arg1 = (Dali::ApplicationExtensions *)jarg1;
51307   {
51308     try {
51309       (arg1)->LanguageChange();
51310     } catch (std::out_of_range& e) {
51311       {
51312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51313       };
51314     } catch (std::exception& e) {
51315       {
51316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51317       };
51318     } catch (...) {
51319       {
51320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51321       };
51322     }
51323   }
51324 }
51325
51326
51327
51328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
51329   unsigned int jresult ;
51330   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51331   bool result;
51332
51333   arg1 = (Dali::Signal< bool () > *)jarg1;
51334   {
51335     try {
51336       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
51337     } catch (std::out_of_range& e) {
51338       {
51339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (std::exception& e) {
51342       {
51343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51344       };
51345     } catch (...) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51348       };
51349     }
51350   }
51351   jresult = result;
51352   return jresult;
51353 }
51354
51355
51356 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
51357   unsigned long jresult ;
51358   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51359   std::size_t result;
51360
51361   arg1 = (Dali::Signal< bool () > *)jarg1;
51362   {
51363     try {
51364       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
51365     } catch (std::out_of_range& e) {
51366       {
51367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51368       };
51369     } catch (std::exception& e) {
51370       {
51371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51372       };
51373     } catch (...) {
51374       {
51375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51376       };
51377     }
51378   }
51379   jresult = (unsigned long)result;
51380   return jresult;
51381 }
51382
51383
51384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
51385   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51386   bool (*arg2)() = (bool (*)()) 0 ;
51387
51388   arg1 = (Dali::Signal< bool () > *)jarg1;
51389   arg2 = (bool (*)())jarg2;
51390   {
51391     try {
51392       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
51393     } catch (std::out_of_range& e) {
51394       {
51395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51396       };
51397     } catch (std::exception& e) {
51398       {
51399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (...) {
51402       {
51403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51404       };
51405     }
51406   }
51407 }
51408
51409
51410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
51411   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51412   bool (*arg2)() = (bool (*)()) 0 ;
51413
51414   arg1 = (Dali::Signal< bool () > *)jarg1;
51415   arg2 = (bool (*)())jarg2;
51416   {
51417     try {
51418       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
51419     } catch (std::out_of_range& e) {
51420       {
51421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51422       };
51423     } catch (std::exception& e) {
51424       {
51425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51426       };
51427     } catch (...) {
51428       {
51429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51430       };
51431     }
51432   }
51433 }
51434
51435
51436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
51437   unsigned int jresult ;
51438   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51439   bool result;
51440
51441   arg1 = (Dali::Signal< bool () > *)jarg1;
51442   {
51443     try {
51444       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
51445     } catch (std::out_of_range& e) {
51446       {
51447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51448       };
51449     } catch (std::exception& e) {
51450       {
51451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51452       };
51453     } catch (...) {
51454       {
51455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51456       };
51457     }
51458   }
51459   jresult = result;
51460   return jresult;
51461 }
51462
51463
51464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
51465   void * jresult ;
51466   Dali::Signal< bool () > *result = 0 ;
51467
51468   {
51469     try {
51470       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
51471     } catch (std::out_of_range& e) {
51472       {
51473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51474       };
51475     } catch (std::exception& e) {
51476       {
51477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51478       };
51479     } catch (...) {
51480       {
51481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51482       };
51483     }
51484   }
51485   jresult = (void *)result;
51486   return jresult;
51487 }
51488
51489
51490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
51491   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
51492
51493   arg1 = (Dali::Signal< bool () > *)jarg1;
51494   {
51495     try {
51496       delete arg1;
51497     } catch (std::out_of_range& e) {
51498       {
51499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51500       };
51501     } catch (std::exception& e) {
51502       {
51503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51504       };
51505     } catch (...) {
51506       {
51507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51508       };
51509     }
51510   }
51511 }
51512
51513
51514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
51515   int jresult ;
51516   int result;
51517
51518   {
51519     try {
51520       result = (int)Dali::Toolkit::Visual::Property::TYPE;
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51532       };
51533     }
51534   }
51535   jresult = (int)result;
51536   return jresult;
51537 }
51538
51539
51540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
51541   int jresult ;
51542   int result;
51543
51544   {
51545     try {
51546       result = (int)Dali::Toolkit::Visual::Property::SHADER;
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51558       };
51559     }
51560   }
51561   jresult = (int)result;
51562   return jresult;
51563 }
51564
51565
51566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
51567   int jresult ;
51568   int result;
51569
51570   {
51571     try {
51572       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
51573     } catch (std::out_of_range& e) {
51574       {
51575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51576       };
51577     } catch (std::exception& e) {
51578       {
51579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51580       };
51581     } catch (...) {
51582       {
51583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51584       };
51585     }
51586   }
51587   jresult = (int)result;
51588   return jresult;
51589 }
51590
51591
51592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
51593   int jresult ;
51594   int result;
51595
51596   {
51597     try {
51598       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
51599     } catch (std::out_of_range& e) {
51600       {
51601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51602       };
51603     } catch (std::exception& e) {
51604       {
51605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51606       };
51607     } catch (...) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51610       };
51611     }
51612   }
51613   jresult = (int)result;
51614   return jresult;
51615 }
51616
51617
51618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
51619   int jresult ;
51620   int result;
51621
51622   {
51623     try {
51624       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
51625     } catch (std::out_of_range& e) {
51626       {
51627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51628       };
51629     } catch (std::exception& e) {
51630       {
51631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51632       };
51633     } catch (...) {
51634       {
51635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51636       };
51637     }
51638   }
51639   jresult = (int)result;
51640   return jresult;
51641 }
51642
51643
51644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
51645   int jresult ;
51646   int result;
51647
51648   {
51649     try {
51650       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
51651     } catch (std::out_of_range& e) {
51652       {
51653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51654       };
51655     } catch (std::exception& e) {
51656       {
51657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51658       };
51659     } catch (...) {
51660       {
51661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51662       };
51663     }
51664   }
51665   jresult = (int)result;
51666   return jresult;
51667 }
51668
51669
51670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
51671   int jresult ;
51672   int result;
51673
51674   {
51675     try {
51676       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
51677     } catch (std::out_of_range& e) {
51678       {
51679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51680       };
51681     } catch (std::exception& e) {
51682       {
51683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51688       };
51689     }
51690   }
51691   jresult = (int)result;
51692   return jresult;
51693 }
51694
51695
51696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
51697   int jresult ;
51698   int result;
51699
51700   {
51701     try {
51702       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
51703     } catch (std::out_of_range& e) {
51704       {
51705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51706       };
51707     } catch (std::exception& e) {
51708       {
51709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51710       };
51711     } catch (...) {
51712       {
51713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51714       };
51715     }
51716   }
51717   jresult = (int)result;
51718   return jresult;
51719 }
51720
51721
51722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
51723   int jresult ;
51724   int result;
51725
51726   {
51727     try {
51728       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
51729     } catch (std::out_of_range& e) {
51730       {
51731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51732       };
51733     } catch (std::exception& e) {
51734       {
51735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51736       };
51737     } catch (...) {
51738       {
51739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51740       };
51741     }
51742   }
51743   jresult = (int)result;
51744   return jresult;
51745 }
51746
51747
51748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
51749   int jresult ;
51750   int result;
51751
51752   {
51753     try {
51754       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
51755     } catch (std::out_of_range& e) {
51756       {
51757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51758       };
51759     } catch (std::exception& e) {
51760       {
51761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51762       };
51763     } catch (...) {
51764       {
51765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51766       };
51767     }
51768   }
51769   jresult = (int)result;
51770   return jresult;
51771 }
51772
51773
51774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
51775   int jresult ;
51776   int result;
51777
51778   {
51779     try {
51780       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
51781     } catch (std::out_of_range& e) {
51782       {
51783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51784       };
51785     } catch (std::exception& e) {
51786       {
51787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51792       };
51793     }
51794   }
51795   jresult = (int)result;
51796   return jresult;
51797 }
51798
51799
51800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
51801   int jresult ;
51802   int result;
51803
51804   {
51805     try {
51806       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
51807     } catch (std::out_of_range& e) {
51808       {
51809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51810       };
51811     } catch (std::exception& e) {
51812       {
51813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51814       };
51815     } catch (...) {
51816       {
51817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51818       };
51819     }
51820   }
51821   jresult = (int)result;
51822   return jresult;
51823 }
51824
51825
51826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
51827   int jresult ;
51828   int result;
51829
51830   {
51831     try {
51832       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
51833     } catch (std::out_of_range& e) {
51834       {
51835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51836       };
51837     } catch (std::exception& e) {
51838       {
51839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51840       };
51841     } catch (...) {
51842       {
51843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51844       };
51845     }
51846   }
51847   jresult = (int)result;
51848   return jresult;
51849 }
51850
51851
51852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
51853   int jresult ;
51854   int result;
51855
51856   {
51857     try {
51858       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
51859     } catch (std::out_of_range& e) {
51860       {
51861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51862       };
51863     } catch (std::exception& e) {
51864       {
51865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51866       };
51867     } catch (...) {
51868       {
51869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51870       };
51871     }
51872   }
51873   jresult = (int)result;
51874   return jresult;
51875 }
51876
51877
51878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
51879   int jresult ;
51880   int result;
51881
51882   {
51883     try {
51884       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (int)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
51905   int jresult ;
51906   int result;
51907
51908   {
51909     try {
51910       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
51911     } catch (std::out_of_range& e) {
51912       {
51913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51914       };
51915     } catch (std::exception& e) {
51916       {
51917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51918       };
51919     } catch (...) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51922       };
51923     }
51924   }
51925   jresult = (int)result;
51926   return jresult;
51927 }
51928
51929
51930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
51931   int jresult ;
51932   int result;
51933
51934   {
51935     try {
51936       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
51937     } catch (std::out_of_range& e) {
51938       {
51939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51940       };
51941     } catch (std::exception& e) {
51942       {
51943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51944       };
51945     } catch (...) {
51946       {
51947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51948       };
51949     }
51950   }
51951   jresult = (int)result;
51952   return jresult;
51953 }
51954
51955
51956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
51957   int jresult ;
51958   int result;
51959
51960   {
51961     try {
51962       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
51963     } catch (std::out_of_range& e) {
51964       {
51965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51966       };
51967     } catch (std::exception& e) {
51968       {
51969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51970       };
51971     } catch (...) {
51972       {
51973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51974       };
51975     }
51976   }
51977   jresult = (int)result;
51978   return jresult;
51979 }
51980
51981
51982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
51983   int jresult ;
51984   int result;
51985
51986   {
51987     try {
51988       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
51989     } catch (std::out_of_range& e) {
51990       {
51991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51992       };
51993     } catch (std::exception& e) {
51994       {
51995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51996       };
51997     } catch (...) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52000       };
52001     }
52002   }
52003   jresult = (int)result;
52004   return jresult;
52005 }
52006
52007
52008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
52009   int jresult ;
52010   int result;
52011
52012   {
52013     try {
52014       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
52015     } catch (std::out_of_range& e) {
52016       {
52017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52018       };
52019     } catch (std::exception& e) {
52020       {
52021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52022       };
52023     } catch (...) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52026       };
52027     }
52028   }
52029   jresult = (int)result;
52030   return jresult;
52031 }
52032
52033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
52034   int jresult ;
52035   int result;
52036
52037   {
52038     try {
52039       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
52040     } catch (std::out_of_range& e) {
52041       {
52042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52043       };
52044     } catch (std::exception& e) {
52045       {
52046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52047       };
52048     } catch (...) {
52049       {
52050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52051       };
52052     }
52053   }
52054   jresult = (int)result;
52055   return jresult;
52056 }
52057
52058
52059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
52060   int jresult ;
52061   int result;
52062   {
52063     try
52064     {
52065       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
52066     } catch (std::out_of_range& e) {
52067       {
52068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52069       };
52070     } catch (std::exception& e) {
52071       {
52072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52073       };
52074     } catch (...) {
52075       {
52076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52077       };
52078     }
52079   }
52080   jresult = (int)result;
52081   return jresult;
52082 }
52083
52084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
52085   int jresult ;
52086   int result;
52087   {
52088     try
52089     {
52090       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
52091     } catch (std::out_of_range& e) {
52092       {
52093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52094       };
52095     } catch (std::exception& e) {
52096       {
52097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52098       };
52099     } catch (...) {
52100       {
52101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52102       };
52103     }
52104   }
52105   jresult = (int)result;
52106   return jresult;
52107 }
52108
52109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
52110   int jresult ;
52111   int result;
52112   {
52113     try
52114     {
52115       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
52116     } catch (std::out_of_range& e) {
52117       {
52118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52119       };
52120     } catch (std::exception& e) {
52121       {
52122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52123       };
52124     } catch (...) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52127       };
52128     }
52129   }
52130   jresult = (int)result;
52131   return jresult;
52132 }
52133
52134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
52135   int jresult ;
52136   int result;
52137   {
52138     try
52139     {
52140       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
52141     } catch (std::out_of_range& e) {
52142       {
52143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52144       };
52145     } catch (std::exception& e) {
52146       {
52147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52148       };
52149     } catch (...) {
52150       {
52151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52152       };
52153     }
52154   }
52155   jresult = (int)result;
52156   return jresult;
52157 }
52158
52159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
52160   int jresult ;
52161   int result;
52162   {
52163     try
52164     {
52165       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
52166     } catch (std::out_of_range& e) {
52167       {
52168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52169       };
52170     } catch (std::exception& e) {
52171       {
52172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52173       };
52174     } catch (...) {
52175       {
52176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52177       };
52178     }
52179   }
52180   jresult = (int)result;
52181   return jresult;
52182 }
52183
52184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
52185   int jresult ;
52186   int result;
52187
52188   {
52189     try {
52190       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
52191     } catch (std::out_of_range& e) {
52192       {
52193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52194       };
52195     } catch (std::exception& e) {
52196       {
52197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52198       };
52199     } catch (...) {
52200       {
52201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52202       };
52203     }
52204   }
52205   jresult = (int)result;
52206   return jresult;
52207 }
52208
52209
52210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
52211   int jresult ;
52212   int result;
52213
52214   {
52215     try {
52216       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
52217     } catch (std::out_of_range& e) {
52218       {
52219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52220       };
52221     } catch (std::exception& e) {
52222       {
52223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52224       };
52225     } catch (...) {
52226       {
52227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52228       };
52229     }
52230   }
52231   jresult = (int)result;
52232   return jresult;
52233 }
52234
52235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
52236   int jresult ;
52237   int result;
52238   {
52239     try
52240     {
52241       result = (int)Dali::Toolkit::DevelImageVisual::Property::RELEASE_POLICY;
52242     } catch (std::out_of_range& e) {
52243       {
52244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52245       };
52246     } catch (std::exception& e) {
52247       {
52248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (...) {
52251       {
52252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52253       };
52254     }
52255   }
52256   jresult = (int)result;
52257   return jresult;
52258 }
52259
52260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
52261   int jresult ;
52262   int result;
52263   {
52264     try
52265     {
52266       result = (int)Dali::Toolkit::DevelImageVisual::Property::LOAD_POLICY;
52267     } catch (std::out_of_range& e) {
52268       {
52269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52270       };
52271     } catch (std::exception& e) {
52272       {
52273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52274       };
52275     } catch (...) {
52276       {
52277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52278       };
52279     }
52280   }
52281   jresult = (int)result;
52282   return jresult;
52283 }
52284
52285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
52286   int jresult ;
52287   int result;
52288   {
52289     try
52290     {
52291       result = (int)Dali::Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION;
52292     } catch (std::out_of_range& e) {
52293       {
52294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52295       };
52296     } catch (std::exception& e) {
52297       {
52298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52299       };
52300     } catch (...) {
52301       {
52302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52303       };
52304     }
52305   }
52306   jresult = (int)result;
52307   return jresult;
52308 }
52309
52310
52311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_get() {
52312   int jresult ;
52313   int result;
52314   {
52315     try
52316     {
52317       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
52318     } catch (std::out_of_range& e) {
52319       {
52320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52321       };
52322     } catch (std::exception& e) {
52323       {
52324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (...) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52329       };
52330     }
52331   }
52332   jresult = (int)result;
52333   return jresult;
52334 }
52335
52336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
52337   int jresult ;
52338   int result;
52339   {
52340     try
52341     {
52342       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
52343     } catch (std::out_of_range& e) {
52344       {
52345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52346       };
52347     } catch (std::exception& e) {
52348       {
52349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52350       };
52351     } catch (...) {
52352       {
52353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52354       };
52355     }
52356   }
52357   jresult = (int)result;
52358   return jresult;
52359 }
52360
52361
52362
52363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
52364   int jresult ;
52365   int result;
52366
52367   {
52368     try {
52369       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
52370     } catch (std::out_of_range& e) {
52371       {
52372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52373       };
52374     } catch (std::exception& e) {
52375       {
52376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52377       };
52378     } catch (...) {
52379       {
52380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52381       };
52382     }
52383   }
52384   jresult = (int)result;
52385   return jresult;
52386 }
52387
52388
52389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
52390   int jresult ;
52391   int result;
52392
52393   {
52394     try {
52395       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
52396     } catch (std::out_of_range& e) {
52397       {
52398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52399       };
52400     } catch (std::exception& e) {
52401       {
52402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52403       };
52404     } catch (...) {
52405       {
52406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52407       };
52408     }
52409   }
52410   jresult = (int)result;
52411   return jresult;
52412 }
52413
52414
52415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
52416   int jresult ;
52417   int result;
52418
52419   {
52420     try {
52421       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
52422     } catch (std::out_of_range& e) {
52423       {
52424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52425       };
52426     } catch (std::exception& e) {
52427       {
52428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52429       };
52430     } catch (...) {
52431       {
52432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52433       };
52434     }
52435   }
52436   jresult = (int)result;
52437   return jresult;
52438 }
52439
52440
52441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
52442   int jresult ;
52443   int result;
52444
52445   {
52446     try {
52447       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52455       };
52456     } catch (...) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52459       };
52460     }
52461   }
52462   jresult = (int)result;
52463   return jresult;
52464 }
52465
52466
52467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
52468   int jresult ;
52469   int result;
52470
52471   {
52472     try {
52473       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
52474     } catch (std::out_of_range& e) {
52475       {
52476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52477       };
52478     } catch (std::exception& e) {
52479       {
52480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52481       };
52482     } catch (...) {
52483       {
52484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52485       };
52486     }
52487   }
52488   jresult = (int)result;
52489   return jresult;
52490 }
52491
52492
52493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
52494   int jresult ;
52495   int result;
52496
52497   {
52498     try {
52499       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
52500     } catch (std::out_of_range& e) {
52501       {
52502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (std::exception& e) {
52505       {
52506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (...) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52511       };
52512     }
52513   }
52514   jresult = (int)result;
52515   return jresult;
52516 }
52517
52518
52519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
52520   int jresult ;
52521   int result;
52522
52523   {
52524     try {
52525       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
52526     } catch (std::out_of_range& e) {
52527       {
52528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (std::exception& e) {
52531       {
52532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (...) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52537       };
52538     }
52539   }
52540   jresult = (int)result;
52541   return jresult;
52542 }
52543
52544 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
52545   int jresult ;
52546   int result;
52547
52548   {
52549     try {
52550       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
52551     } catch (std::out_of_range& e) {
52552       {
52553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52554       };
52555     } catch (std::exception& e) {
52556       {
52557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (...) {
52560       {
52561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52562       };
52563     }
52564   }
52565   jresult = (int)result;
52566   return jresult;
52567 }
52568
52569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
52570   int jresult ;
52571   int result;
52572
52573   {
52574     try {
52575       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
52576     } catch (std::out_of_range& e) {
52577       {
52578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (std::exception& e) {
52581       {
52582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52583       };
52584     } catch (...) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52587       };
52588     }
52589   }
52590   jresult = (int)result;
52591   return jresult;
52592 }
52593
52594
52595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
52596   int jresult ;
52597   int result;
52598
52599   {
52600     try {
52601       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
52602     } catch (std::out_of_range& e) {
52603       {
52604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52605       };
52606     } catch (std::exception& e) {
52607       {
52608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52609       };
52610     } catch (...) {
52611       {
52612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52613       };
52614     }
52615   }
52616   jresult = (int)result;
52617   return jresult;
52618 }
52619
52620
52621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
52622   int jresult ;
52623   int result;
52624
52625   {
52626     try {
52627       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
52628     } catch (std::out_of_range& e) {
52629       {
52630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (std::exception& e) {
52633       {
52634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52635       };
52636     } catch (...) {
52637       {
52638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52639       };
52640     }
52641   }
52642   jresult = (int)result;
52643   return jresult;
52644 }
52645
52646
52647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
52648   int jresult ;
52649   int result;
52650
52651   {
52652     try {
52653       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
52654     } catch (std::out_of_range& e) {
52655       {
52656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52657       };
52658     } catch (std::exception& e) {
52659       {
52660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52661       };
52662     } catch (...) {
52663       {
52664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52665       };
52666     }
52667   }
52668   jresult = (int)result;
52669   return jresult;
52670 }
52671
52672
52673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
52674   int jresult ;
52675   int result;
52676
52677   {
52678     try {
52679       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
52680     } catch (std::out_of_range& e) {
52681       {
52682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52683       };
52684     } catch (std::exception& e) {
52685       {
52686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52691       };
52692     }
52693   }
52694   jresult = (int)result;
52695   return jresult;
52696 }
52697
52698
52699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
52700   int jresult ;
52701   int result;
52702
52703   {
52704     try {
52705       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
52706     } catch (std::out_of_range& e) {
52707       {
52708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52709       };
52710     } catch (std::exception& e) {
52711       {
52712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52713       };
52714     } catch (...) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52717       };
52718     }
52719   }
52720   jresult = (int)result;
52721   return jresult;
52722 }
52723
52724
52725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
52726   int jresult ;
52727   int result;
52728
52729   {
52730     try {
52731       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
52732     } catch (std::out_of_range& e) {
52733       {
52734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52735       };
52736     } catch (std::exception& e) {
52737       {
52738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52739       };
52740     } catch (...) {
52741       {
52742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52743       };
52744     }
52745   }
52746   jresult = (int)result;
52747   return jresult;
52748 }
52749
52750
52751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
52752   int jresult ;
52753   int result;
52754
52755   {
52756     try {
52757       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
52758     } catch (std::out_of_range& e) {
52759       {
52760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52761       };
52762     } catch (std::exception& e) {
52763       {
52764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52765       };
52766     } catch (...) {
52767       {
52768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52769       };
52770     }
52771   }
52772   jresult = (int)result;
52773   return jresult;
52774 }
52775
52776
52777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
52778   int jresult ;
52779   int result;
52780
52781   {
52782     try {
52783       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
52784     } catch (std::out_of_range& e) {
52785       {
52786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52787       };
52788     } catch (std::exception& e) {
52789       {
52790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52791       };
52792     } catch (...) {
52793       {
52794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52795       };
52796     }
52797   }
52798   jresult = (int)result;
52799   return jresult;
52800 }
52801
52802
52803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
52804   int jresult ;
52805   int result;
52806
52807   {
52808     try {
52809       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
52810     } catch (std::out_of_range& e) {
52811       {
52812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52813       };
52814     } catch (std::exception& e) {
52815       {
52816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52817       };
52818     } catch (...) {
52819       {
52820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52821       };
52822     }
52823   }
52824   jresult = (int)result;
52825   return jresult;
52826 }
52827
52828
52829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
52830   int jresult ;
52831   int result;
52832
52833   {
52834     try {
52835       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
52836     } catch (std::out_of_range& e) {
52837       {
52838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52839       };
52840     } catch (std::exception& e) {
52841       {
52842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52843       };
52844     } catch (...) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52847       };
52848     }
52849   }
52850   jresult = (int)result;
52851   return jresult;
52852 }
52853
52854
52855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
52856   int jresult ;
52857   int result;
52858
52859   {
52860     try {
52861       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
52862     } catch (std::out_of_range& e) {
52863       {
52864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52865       };
52866     } catch (std::exception& e) {
52867       {
52868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52869       };
52870     } catch (...) {
52871       {
52872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52873       };
52874     }
52875   }
52876   jresult = (int)result;
52877   return jresult;
52878 }
52879
52880
52881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
52882   int jresult ;
52883   int result;
52884
52885   {
52886     try {
52887       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
52888     } catch (std::out_of_range& e) {
52889       {
52890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52891       };
52892     } catch (std::exception& e) {
52893       {
52894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52895       };
52896     } catch (...) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52899       };
52900     }
52901   }
52902   jresult = (int)result;
52903   return jresult;
52904 }
52905
52906
52907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
52908   int jresult ;
52909   int result;
52910
52911   {
52912     try {
52913       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
52914     } catch (std::out_of_range& e) {
52915       {
52916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52917       };
52918     } catch (std::exception& e) {
52919       {
52920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52921       };
52922     } catch (...) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52925       };
52926     }
52927   }
52928   jresult = (int)result;
52929   return jresult;
52930 }
52931
52932
52933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
52934   int jresult ;
52935   int result;
52936
52937   {
52938     try {
52939       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
52940     } catch (std::out_of_range& e) {
52941       {
52942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52943       };
52944     } catch (std::exception& e) {
52945       {
52946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52947       };
52948     } catch (...) {
52949       {
52950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52951       };
52952     }
52953   }
52954   jresult = (int)result;
52955   return jresult;
52956 }
52957
52958
52959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
52960   int jresult ;
52961   int result;
52962
52963   {
52964     try {
52965       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
52966     } catch (std::out_of_range& e) {
52967       {
52968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52969       };
52970     } catch (std::exception& e) {
52971       {
52972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52973       };
52974     } catch (...) {
52975       {
52976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52977       };
52978     }
52979   }
52980   jresult = (int)result;
52981   return jresult;
52982 }
52983
52984
52985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
52986   int jresult ;
52987   int result;
52988
52989   {
52990     try {
52991       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
52992     } catch (std::out_of_range& e) {
52993       {
52994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52995       };
52996     } catch (std::exception& e) {
52997       {
52998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52999       };
53000     } catch (...) {
53001       {
53002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53003       };
53004     }
53005   }
53006   jresult = (int)result;
53007   return jresult;
53008 }
53009
53010
53011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
53012   int jresult ;
53013   int result;
53014
53015   {
53016     try {
53017       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
53018     } catch (std::out_of_range& e) {
53019       {
53020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53021       };
53022     } catch (std::exception& e) {
53023       {
53024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53025       };
53026     } catch (...) {
53027       {
53028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53029       };
53030     }
53031   }
53032   jresult = (int)result;
53033   return jresult;
53034 }
53035
53036
53037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
53038   int jresult ;
53039   int result;
53040
53041   {
53042     try {
53043       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53055       };
53056     }
53057   }
53058   jresult = (int)result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
53064   int jresult ;
53065   int result;
53066
53067   {
53068     try {
53069       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53077       };
53078     } catch (...) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53081       };
53082     }
53083   }
53084   jresult = (int)result;
53085   return jresult;
53086 }
53087
53088
53089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
53090   int jresult ;
53091   int result;
53092
53093   {
53094     try {
53095       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
53096     } catch (std::out_of_range& e) {
53097       {
53098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53099       };
53100     } catch (std::exception& e) {
53101       {
53102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53103       };
53104     } catch (...) {
53105       {
53106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53107       };
53108     }
53109   }
53110   jresult = (int)result;
53111   return jresult;
53112 }
53113
53114
53115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
53116   int jresult ;
53117   int result;
53118
53119   {
53120     try {
53121       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
53122     } catch (std::out_of_range& e) {
53123       {
53124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53125       };
53126     } catch (std::exception& e) {
53127       {
53128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53129       };
53130     } catch (...) {
53131       {
53132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53133       };
53134     }
53135   }
53136   jresult = (int)result;
53137   return jresult;
53138 }
53139
53140
53141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
53142   int jresult ;
53143   int result;
53144
53145   {
53146     try {
53147       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
53148     } catch (std::out_of_range& e) {
53149       {
53150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53151       };
53152     } catch (std::exception& e) {
53153       {
53154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (...) {
53157       {
53158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53159       };
53160     }
53161   }
53162   jresult = (int)result;
53163   return jresult;
53164 }
53165
53166
53167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
53168   int jresult ;
53169   int result;
53170
53171   {
53172     try {
53173       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
53174     } catch (std::out_of_range& e) {
53175       {
53176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53177       };
53178     } catch (std::exception& e) {
53179       {
53180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53181       };
53182     } catch (...) {
53183       {
53184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53185       };
53186     }
53187   }
53188   jresult = (int)result;
53189   return jresult;
53190 }
53191
53192
53193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
53194   int jresult ;
53195   int result;
53196
53197   {
53198     try {
53199       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
53200     } catch (std::out_of_range& e) {
53201       {
53202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53203       };
53204     } catch (std::exception& e) {
53205       {
53206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (...) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53211       };
53212     }
53213   }
53214   jresult = (int)result;
53215   return jresult;
53216 }
53217
53218
53219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
53220   int jresult ;
53221   int result;
53222
53223   {
53224     try {
53225       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
53226     } catch (std::out_of_range& e) {
53227       {
53228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53229       };
53230     } catch (std::exception& e) {
53231       {
53232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53233       };
53234     } catch (...) {
53235       {
53236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53237       };
53238     }
53239   }
53240   jresult = (int)result;
53241   return jresult;
53242 }
53243
53244
53245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
53246   int jresult ;
53247   int result;
53248
53249   {
53250     try {
53251       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
53252     } catch (std::out_of_range& e) {
53253       {
53254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53255       };
53256     } catch (std::exception& e) {
53257       {
53258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53259       };
53260     } catch (...) {
53261       {
53262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53263       };
53264     }
53265   }
53266   jresult = (int)result;
53267   return jresult;
53268 }
53269
53270
53271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
53272   int jresult ;
53273   int result;
53274
53275   {
53276     try {
53277       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
53278     } catch (std::out_of_range& e) {
53279       {
53280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53281       };
53282     } catch (std::exception& e) {
53283       {
53284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53285       };
53286     } catch (...) {
53287       {
53288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53289       };
53290     }
53291   }
53292   jresult = (int)result;
53293   return jresult;
53294 }
53295
53296
53297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
53298   void * jresult ;
53299   Dali::Toolkit::Builder *result = 0 ;
53300
53301   {
53302     try {
53303       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
53304     } catch (std::out_of_range& e) {
53305       {
53306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53307       };
53308     } catch (std::exception& e) {
53309       {
53310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53311       };
53312     } catch (...) {
53313       {
53314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53315       };
53316     }
53317   }
53318   jresult = (void *)result;
53319   return jresult;
53320 }
53321
53322
53323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
53324   void * jresult ;
53325   Dali::Toolkit::Builder result;
53326
53327   {
53328     try {
53329       result = Dali::Toolkit::Builder::New();
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53337       };
53338     } catch (...) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53341       };
53342     }
53343   }
53344   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
53345   return jresult;
53346 }
53347
53348
53349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
53350   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53351
53352   arg1 = (Dali::Toolkit::Builder *)jarg1;
53353   {
53354     try {
53355       delete arg1;
53356     } catch (std::out_of_range& e) {
53357       {
53358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53359       };
53360     } catch (std::exception& e) {
53361       {
53362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53363       };
53364     } catch (...) {
53365       {
53366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53367       };
53368     }
53369   }
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
53374   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53375   std::string *arg2 = 0 ;
53376   Dali::Toolkit::Builder::UIFormat arg3 ;
53377
53378   arg1 = (Dali::Toolkit::Builder *)jarg1;
53379   if (!jarg2) {
53380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53381     return ;
53382   }
53383   std::string arg2_str(jarg2);
53384   arg2 = &arg2_str;
53385   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
53386   {
53387     try {
53388       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
53389     } catch (std::out_of_range& e) {
53390       {
53391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (std::exception& e) {
53394       {
53395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53396       };
53397     } catch (...) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53400       };
53401     }
53402   }
53403
53404   //argout typemap for const std::string&
53405
53406 }
53407
53408
53409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
53410   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53411   std::string *arg2 = 0 ;
53412
53413   arg1 = (Dali::Toolkit::Builder *)jarg1;
53414   if (!jarg2) {
53415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53416     return ;
53417   }
53418   std::string arg2_str(jarg2);
53419   arg2 = &arg2_str;
53420   {
53421     try {
53422       (arg1)->LoadFromString((std::string const &)*arg2);
53423     } catch (std::out_of_range& e) {
53424       {
53425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53426       };
53427     } catch (std::exception& e) {
53428       {
53429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53430       };
53431     } catch (...) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53434       };
53435     }
53436   }
53437
53438   //argout typemap for const std::string&
53439
53440 }
53441
53442
53443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
53444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53445   Dali::Property::Map *arg2 = 0 ;
53446
53447   arg1 = (Dali::Toolkit::Builder *)jarg1;
53448   arg2 = (Dali::Property::Map *)jarg2;
53449   if (!arg2) {
53450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53451     return ;
53452   }
53453   {
53454     try {
53455       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
53456     } catch (std::out_of_range& e) {
53457       {
53458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53459       };
53460     } catch (std::exception& e) {
53461       {
53462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53463       };
53464     } catch (...) {
53465       {
53466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53467       };
53468     }
53469   }
53470 }
53471
53472
53473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
53474   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53475   std::string *arg2 = 0 ;
53476   Dali::Property::Value *arg3 = 0 ;
53477
53478   arg1 = (Dali::Toolkit::Builder *)jarg1;
53479   if (!jarg2) {
53480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53481     return ;
53482   }
53483   std::string arg2_str(jarg2);
53484   arg2 = &arg2_str;
53485   arg3 = (Dali::Property::Value *)jarg3;
53486   if (!arg3) {
53487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
53488     return ;
53489   }
53490   {
53491     try {
53492       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
53493     } catch (std::out_of_range& e) {
53494       {
53495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53496       };
53497     } catch (std::exception& e) {
53498       {
53499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53500       };
53501     } catch (...) {
53502       {
53503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53504       };
53505     }
53506   }
53507
53508   //argout typemap for const std::string&
53509
53510 }
53511
53512
53513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
53514   void * jresult ;
53515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53516   Dali::Property::Map *result = 0 ;
53517
53518   arg1 = (Dali::Toolkit::Builder *)jarg1;
53519   {
53520     try {
53521       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
53522     } catch (std::out_of_range& e) {
53523       {
53524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53525       };
53526     } catch (std::exception& e) {
53527       {
53528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53533       };
53534     }
53535   }
53536   jresult = (void *)result;
53537   return jresult;
53538 }
53539
53540
53541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
53542   void * jresult ;
53543   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53544   std::string *arg2 = 0 ;
53545   Dali::Property::Value *result = 0 ;
53546
53547   arg1 = (Dali::Toolkit::Builder *)jarg1;
53548   if (!jarg2) {
53549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53550     return 0;
53551   }
53552   std::string arg2_str(jarg2);
53553   arg2 = &arg2_str;
53554   {
53555     try {
53556       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53568       };
53569     }
53570   }
53571   jresult = (void *)result;
53572
53573   //argout typemap for const std::string&
53574
53575   return jresult;
53576 }
53577
53578
53579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
53580   void * jresult ;
53581   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53582   std::string *arg2 = 0 ;
53583   Dali::Animation result;
53584
53585   arg1 = (Dali::Toolkit::Builder *)jarg1;
53586   if (!jarg2) {
53587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53588     return 0;
53589   }
53590   std::string arg2_str(jarg2);
53591   arg2 = &arg2_str;
53592   {
53593     try {
53594       result = (arg1)->CreateAnimation((std::string const &)*arg2);
53595     } catch (std::out_of_range& e) {
53596       {
53597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53598       };
53599     } catch (std::exception& e) {
53600       {
53601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53602       };
53603     } catch (...) {
53604       {
53605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53606       };
53607     }
53608   }
53609   jresult = new Dali::Animation((const Dali::Animation &)result);
53610
53611   //argout typemap for const std::string&
53612
53613   return jresult;
53614 }
53615
53616
53617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53618   void * jresult ;
53619   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53620   std::string *arg2 = 0 ;
53621   Dali::Property::Map *arg3 = 0 ;
53622   Dali::Animation result;
53623
53624   arg1 = (Dali::Toolkit::Builder *)jarg1;
53625   if (!jarg2) {
53626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53627     return 0;
53628   }
53629   std::string arg2_str(jarg2);
53630   arg2 = &arg2_str;
53631   arg3 = (Dali::Property::Map *)jarg3;
53632   if (!arg3) {
53633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53634     return 0;
53635   }
53636   {
53637     try {
53638       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53639     } catch (std::out_of_range& e) {
53640       {
53641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53642       };
53643     } catch (std::exception& e) {
53644       {
53645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53646       };
53647     } catch (...) {
53648       {
53649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53650       };
53651     }
53652   }
53653   jresult = new Dali::Animation((const Dali::Animation &)result);
53654
53655   //argout typemap for const std::string&
53656
53657   return jresult;
53658 }
53659
53660
53661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
53662   void * jresult ;
53663   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53664   std::string *arg2 = 0 ;
53665   Dali::Actor arg3 ;
53666   Dali::Actor *argp3 ;
53667   Dali::Animation result;
53668
53669   arg1 = (Dali::Toolkit::Builder *)jarg1;
53670   if (!jarg2) {
53671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53672     return 0;
53673   }
53674   std::string arg2_str(jarg2);
53675   arg2 = &arg2_str;
53676   argp3 = (Dali::Actor *)jarg3;
53677   if (!argp3) {
53678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53679     return 0;
53680   }
53681   arg3 = *argp3;
53682   {
53683     try {
53684       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
53685     } catch (std::out_of_range& e) {
53686       {
53687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53688       };
53689     } catch (std::exception& e) {
53690       {
53691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53692       };
53693     } catch (...) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53696       };
53697     }
53698   }
53699   jresult = new Dali::Animation((const Dali::Animation &)result);
53700
53701   //argout typemap for const std::string&
53702
53703   return jresult;
53704 }
53705
53706
53707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
53708   void * jresult ;
53709   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53710   std::string *arg2 = 0 ;
53711   Dali::Property::Map *arg3 = 0 ;
53712   Dali::Actor arg4 ;
53713   Dali::Actor *argp4 ;
53714   Dali::Animation result;
53715
53716   arg1 = (Dali::Toolkit::Builder *)jarg1;
53717   if (!jarg2) {
53718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53719     return 0;
53720   }
53721   std::string arg2_str(jarg2);
53722   arg2 = &arg2_str;
53723   arg3 = (Dali::Property::Map *)jarg3;
53724   if (!arg3) {
53725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53726     return 0;
53727   }
53728   argp4 = (Dali::Actor *)jarg4;
53729   if (!argp4) {
53730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53731     return 0;
53732   }
53733   arg4 = *argp4;
53734   {
53735     try {
53736       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
53737     } catch (std::out_of_range& e) {
53738       {
53739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53740       };
53741     } catch (std::exception& e) {
53742       {
53743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53744       };
53745     } catch (...) {
53746       {
53747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53748       };
53749     }
53750   }
53751   jresult = new Dali::Animation((const Dali::Animation &)result);
53752
53753   //argout typemap for const std::string&
53754
53755   return jresult;
53756 }
53757
53758
53759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
53760   void * jresult ;
53761   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53762   std::string *arg2 = 0 ;
53763   Dali::BaseHandle result;
53764
53765   arg1 = (Dali::Toolkit::Builder *)jarg1;
53766   if (!jarg2) {
53767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53768     return 0;
53769   }
53770   std::string arg2_str(jarg2);
53771   arg2 = &arg2_str;
53772   {
53773     try {
53774       result = (arg1)->Create((std::string const &)*arg2);
53775     } catch (std::out_of_range& e) {
53776       {
53777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (std::exception& e) {
53780       {
53781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53790
53791   //argout typemap for const std::string&
53792
53793   return jresult;
53794 }
53795
53796
53797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
53798   void * jresult ;
53799   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53800   std::string *arg2 = 0 ;
53801   Dali::Property::Map *arg3 = 0 ;
53802   Dali::BaseHandle result;
53803
53804   arg1 = (Dali::Toolkit::Builder *)jarg1;
53805   if (!jarg2) {
53806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53807     return 0;
53808   }
53809   std::string arg2_str(jarg2);
53810   arg2 = &arg2_str;
53811   arg3 = (Dali::Property::Map *)jarg3;
53812   if (!arg3) {
53813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
53814     return 0;
53815   }
53816   {
53817     try {
53818       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (...) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53830       };
53831     }
53832   }
53833   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53834
53835   //argout typemap for const std::string&
53836
53837   return jresult;
53838 }
53839
53840
53841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
53842   void * jresult ;
53843   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53844   std::string *arg2 = 0 ;
53845   Dali::BaseHandle result;
53846
53847   arg1 = (Dali::Toolkit::Builder *)jarg1;
53848   if (!jarg2) {
53849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53850     return 0;
53851   }
53852   std::string arg2_str(jarg2);
53853   arg2 = &arg2_str;
53854   {
53855     try {
53856       result = (arg1)->CreateFromJson((std::string const &)*arg2);
53857     } catch (std::out_of_range& e) {
53858       {
53859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53860       };
53861     } catch (std::exception& e) {
53862       {
53863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53864       };
53865     } catch (...) {
53866       {
53867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53868       };
53869     }
53870   }
53871   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
53872
53873   //argout typemap for const std::string&
53874
53875   return jresult;
53876 }
53877
53878
53879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
53880   unsigned int jresult ;
53881   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53882   std::string *arg2 = 0 ;
53883   Dali::Handle *arg3 = 0 ;
53884   bool result;
53885
53886   arg1 = (Dali::Toolkit::Builder *)jarg1;
53887   if (!jarg2) {
53888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53889     return 0;
53890   }
53891   std::string arg2_str(jarg2);
53892   arg2 = &arg2_str;
53893   arg3 = (Dali::Handle *)jarg3;
53894   if (!arg3) {
53895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53896     return 0;
53897   }
53898   {
53899     try {
53900       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
53901     } catch (std::out_of_range& e) {
53902       {
53903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53904       };
53905     } catch (std::exception& e) {
53906       {
53907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53908       };
53909     } catch (...) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53912       };
53913     }
53914   }
53915   jresult = result;
53916
53917   //argout typemap for const std::string&
53918
53919   return jresult;
53920 }
53921
53922
53923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
53924   unsigned int jresult ;
53925   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53926   Dali::Handle *arg2 = 0 ;
53927   std::string *arg3 = 0 ;
53928   bool result;
53929
53930   arg1 = (Dali::Toolkit::Builder *)jarg1;
53931   arg2 = (Dali::Handle *)jarg2;
53932   if (!arg2) {
53933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
53934     return 0;
53935   }
53936   if (!jarg3) {
53937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53938     return 0;
53939   }
53940   std::string arg3_str(jarg3);
53941   arg3 = &arg3_str;
53942   {
53943     try {
53944       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
53945     } catch (std::out_of_range& e) {
53946       {
53947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53948       };
53949     } catch (std::exception& e) {
53950       {
53951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53952       };
53953     } catch (...) {
53954       {
53955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53956       };
53957     }
53958   }
53959   jresult = result;
53960
53961   //argout typemap for const std::string&
53962
53963   return jresult;
53964 }
53965
53966
53967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
53968   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
53969   Dali::Actor arg2 ;
53970   Dali::Actor *argp2 ;
53971
53972   arg1 = (Dali::Toolkit::Builder *)jarg1;
53973   argp2 = (Dali::Actor *)jarg2;
53974   if (!argp2) {
53975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53976     return ;
53977   }
53978   arg2 = *argp2;
53979   {
53980     try {
53981       (arg1)->AddActors(arg2);
53982     } catch (std::out_of_range& e) {
53983       {
53984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (std::exception& e) {
53987       {
53988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53989       };
53990     } catch (...) {
53991       {
53992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53993       };
53994     }
53995   }
53996 }
53997
53998
53999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
54000   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54001   std::string *arg2 = 0 ;
54002   Dali::Actor arg3 ;
54003   Dali::Actor *argp3 ;
54004
54005   arg1 = (Dali::Toolkit::Builder *)jarg1;
54006   if (!jarg2) {
54007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54008     return ;
54009   }
54010   std::string arg2_str(jarg2);
54011   arg2 = &arg2_str;
54012   argp3 = (Dali::Actor *)jarg3;
54013   if (!argp3) {
54014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54015     return ;
54016   }
54017   arg3 = *argp3;
54018   {
54019     try {
54020       (arg1)->AddActors((std::string const &)*arg2,arg3);
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (...) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54032       };
54033     }
54034   }
54035
54036   //argout typemap for const std::string&
54037
54038 }
54039
54040
54041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
54042   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54043   std::string *arg2 = 0 ;
54044
54045   arg1 = (Dali::Toolkit::Builder *)jarg1;
54046   if (!jarg2) {
54047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54048     return ;
54049   }
54050   std::string arg2_str(jarg2);
54051   arg2 = &arg2_str;
54052   {
54053     try {
54054       (arg1)->CreateRenderTask((std::string const &)*arg2);
54055     } catch (std::out_of_range& e) {
54056       {
54057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54058       };
54059     } catch (std::exception& e) {
54060       {
54061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54062       };
54063     } catch (...) {
54064       {
54065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54066       };
54067     }
54068   }
54069
54070   //argout typemap for const std::string&
54071
54072 }
54073
54074
54075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
54076   void * jresult ;
54077   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54078   std::string *arg2 = 0 ;
54079   Dali::FrameBufferImage result;
54080
54081   arg1 = (Dali::Toolkit::Builder *)jarg1;
54082   if (!jarg2) {
54083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54084     return 0;
54085   }
54086   std::string arg2_str(jarg2);
54087   arg2 = &arg2_str;
54088   {
54089     try {
54090       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
54091     } catch (std::out_of_range& e) {
54092       {
54093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54094       };
54095     } catch (std::exception& e) {
54096       {
54097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54098       };
54099     } catch (...) {
54100       {
54101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54102       };
54103     }
54104   }
54105   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
54106
54107   //argout typemap for const std::string&
54108
54109   return jresult;
54110 }
54111
54112
54113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
54114   void * jresult ;
54115   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54116   std::string *arg2 = 0 ;
54117   Dali::Path result;
54118
54119   arg1 = (Dali::Toolkit::Builder *)jarg1;
54120   if (!jarg2) {
54121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54122     return 0;
54123   }
54124   std::string arg2_str(jarg2);
54125   arg2 = &arg2_str;
54126   {
54127     try {
54128       result = (arg1)->GetPath((std::string const &)*arg2);
54129     } catch (std::out_of_range& e) {
54130       {
54131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54132       };
54133     } catch (std::exception& e) {
54134       {
54135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54136       };
54137     } catch (...) {
54138       {
54139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54140       };
54141     }
54142   }
54143   jresult = new Dali::Path((const Dali::Path &)result);
54144
54145   //argout typemap for const std::string&
54146
54147   return jresult;
54148 }
54149
54150
54151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
54152   void * jresult ;
54153   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54154   std::string *arg2 = 0 ;
54155   Dali::PathConstrainer result;
54156
54157   arg1 = (Dali::Toolkit::Builder *)jarg1;
54158   if (!jarg2) {
54159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54160     return 0;
54161   }
54162   std::string arg2_str(jarg2);
54163   arg2 = &arg2_str;
54164   {
54165     try {
54166       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
54167     } catch (std::out_of_range& e) {
54168       {
54169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54170       };
54171     } catch (std::exception& e) {
54172       {
54173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54174       };
54175     } catch (...) {
54176       {
54177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54178       };
54179     }
54180   }
54181   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
54182
54183   //argout typemap for const std::string&
54184
54185   return jresult;
54186 }
54187
54188
54189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
54190   void * jresult ;
54191   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54192   std::string *arg2 = 0 ;
54193   Dali::LinearConstrainer result;
54194
54195   arg1 = (Dali::Toolkit::Builder *)jarg1;
54196   if (!jarg2) {
54197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54198     return 0;
54199   }
54200   std::string arg2_str(jarg2);
54201   arg2 = &arg2_str;
54202   {
54203     try {
54204       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
54205     } catch (std::out_of_range& e) {
54206       {
54207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54208       };
54209     } catch (std::exception& e) {
54210       {
54211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54212       };
54213     } catch (...) {
54214       {
54215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54216       };
54217     }
54218   }
54219   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
54220
54221   //argout typemap for const std::string&
54222
54223   return jresult;
54224 }
54225
54226
54227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
54228   void * jresult ;
54229   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
54230   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
54231
54232   arg1 = (Dali::Toolkit::Builder *)jarg1;
54233   {
54234     try {
54235       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
54236     } catch (std::out_of_range& e) {
54237       {
54238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54239       };
54240     } catch (std::exception& e) {
54241       {
54242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54243       };
54244     } catch (...) {
54245       {
54246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54247       };
54248     }
54249   }
54250   jresult = (void *)result;
54251   return jresult;
54252 }
54253
54254
54255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
54256   void * jresult ;
54257   Dali::Toolkit::TransitionData *result = 0 ;
54258
54259   {
54260     try {
54261       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
54262     } catch (std::out_of_range& e) {
54263       {
54264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54265       };
54266     } catch (std::exception& e) {
54267       {
54268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54269       };
54270     } catch (...) {
54271       {
54272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54273       };
54274     }
54275   }
54276   jresult = (void *)result;
54277   return jresult;
54278 }
54279
54280
54281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
54282   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54283
54284   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54285   {
54286     try {
54287       delete arg1;
54288     } catch (std::out_of_range& e) {
54289       {
54290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54291       };
54292     } catch (std::exception& e) {
54293       {
54294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54299       };
54300     }
54301   }
54302 }
54303
54304
54305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
54306   void * jresult ;
54307   Dali::Property::Map *arg1 = 0 ;
54308   Dali::Toolkit::TransitionData result;
54309
54310   arg1 = (Dali::Property::Map *)jarg1;
54311   if (!arg1) {
54312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
54313     return 0;
54314   }
54315   {
54316     try {
54317       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
54318     } catch (std::out_of_range& e) {
54319       {
54320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54321       };
54322     } catch (std::exception& e) {
54323       {
54324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (...) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54329       };
54330     }
54331   }
54332   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
54338   void * jresult ;
54339   Dali::Property::Array *arg1 = 0 ;
54340   Dali::Toolkit::TransitionData result;
54341
54342   arg1 = (Dali::Property::Array *)jarg1;
54343   if (!arg1) {
54344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
54345     return 0;
54346   }
54347   {
54348     try {
54349       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54361       };
54362     }
54363   }
54364   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54365   return jresult;
54366 }
54367
54368
54369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
54370   void * jresult ;
54371   Dali::BaseHandle arg1 ;
54372   Dali::BaseHandle *argp1 ;
54373   Dali::Toolkit::TransitionData result;
54374
54375   argp1 = (Dali::BaseHandle *)jarg1;
54376   if (!argp1) {
54377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54378     return 0;
54379   }
54380   arg1 = *argp1;
54381   {
54382     try {
54383       result = Dali::Toolkit::TransitionData::DownCast(arg1);
54384     } catch (std::out_of_range& e) {
54385       {
54386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54387       };
54388     } catch (std::exception& e) {
54389       {
54390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54391       };
54392     } catch (...) {
54393       {
54394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54395       };
54396     }
54397   }
54398   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
54399   return jresult;
54400 }
54401
54402
54403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
54404   void * jresult ;
54405   Dali::Toolkit::TransitionData *arg1 = 0 ;
54406   Dali::Toolkit::TransitionData *result = 0 ;
54407
54408   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54409   if (!arg1) {
54410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54411     return 0;
54412   }
54413   {
54414     try {
54415       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
54416     } catch (std::out_of_range& e) {
54417       {
54418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (std::exception& e) {
54421       {
54422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54423       };
54424     } catch (...) {
54425       {
54426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54427       };
54428     }
54429   }
54430   jresult = (void *)result;
54431   return jresult;
54432 }
54433
54434
54435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
54436   void * jresult ;
54437   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54438   Dali::Toolkit::TransitionData *arg2 = 0 ;
54439   Dali::Toolkit::TransitionData *result = 0 ;
54440
54441   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54442   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
54443   if (!arg2) {
54444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
54445     return 0;
54446   }
54447   {
54448     try {
54449       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
54450     } catch (std::out_of_range& e) {
54451       {
54452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54453       };
54454     } catch (std::exception& e) {
54455       {
54456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54457       };
54458     } catch (...) {
54459       {
54460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54461       };
54462     }
54463   }
54464   jresult = (void *)result;
54465   return jresult;
54466 }
54467
54468
54469 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
54470   unsigned long jresult ;
54471   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54472   size_t result;
54473
54474   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54475   {
54476     try {
54477       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
54478     } catch (std::out_of_range& e) {
54479       {
54480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (std::exception& e) {
54483       {
54484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54485       };
54486     } catch (...) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54489       };
54490     }
54491   }
54492   jresult = (unsigned long)result;
54493   return jresult;
54494 }
54495
54496
54497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
54498   void * jresult ;
54499   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
54500   size_t arg2 ;
54501   Dali::Property::Map result;
54502
54503   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
54504   arg2 = (size_t)jarg2;
54505   {
54506     try {
54507       result = (arg1)->GetAnimatorAt(arg2);
54508     } catch (std::out_of_range& e) {
54509       {
54510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54511       };
54512     } catch (std::exception& e) {
54513       {
54514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54515       };
54516     } catch (...) {
54517       {
54518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54519       };
54520     }
54521   }
54522   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
54523   return jresult;
54524 }
54525
54526
54527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
54528   void * jresult ;
54529   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
54530   Dali::Toolkit::TransitionData *result = 0 ;
54531
54532   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
54533   {
54534     try {
54535       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
54536     } catch (std::out_of_range& e) {
54537       {
54538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54539       };
54540     } catch (std::exception& e) {
54541       {
54542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54543       };
54544     } catch (...) {
54545       {
54546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54547       };
54548     }
54549   }
54550   jresult = (void *)result;
54551   return jresult;
54552 }
54553
54554
54555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
54556   int jresult ;
54557   int result;
54558
54559   {
54560     try {
54561       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
54562     } catch (std::out_of_range& e) {
54563       {
54564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54565       };
54566     } catch (std::exception& e) {
54567       {
54568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54573       };
54574     }
54575   }
54576   jresult = (int)result;
54577   return jresult;
54578 }
54579
54580
54581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
54582   int jresult ;
54583   int result;
54584
54585   {
54586     try {
54587       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
54588     } catch (std::out_of_range& e) {
54589       {
54590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54591       };
54592     } catch (std::exception& e) {
54593       {
54594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54595       };
54596     } catch (...) {
54597       {
54598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54599       };
54600     }
54601   }
54602   jresult = (int)result;
54603   return jresult;
54604 }
54605
54606
54607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
54608   int jresult ;
54609   int result;
54610
54611   {
54612     try {
54613       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
54614     } catch (std::out_of_range& e) {
54615       {
54616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54617       };
54618     } catch (std::exception& e) {
54619       {
54620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54621       };
54622     } catch (...) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54625       };
54626     }
54627   }
54628   jresult = (int)result;
54629   return jresult;
54630 }
54631
54632
54633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
54634   int jresult ;
54635   int result;
54636
54637   {
54638     try {
54639       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
54640     } catch (std::out_of_range& e) {
54641       {
54642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54643       };
54644     } catch (std::exception& e) {
54645       {
54646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54647       };
54648     } catch (...) {
54649       {
54650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54651       };
54652     }
54653   }
54654   jresult = (int)result;
54655   return jresult;
54656 }
54657
54658
54659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
54660   int jresult ;
54661   int result;
54662
54663   {
54664     try {
54665       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
54666     } catch (std::out_of_range& e) {
54667       {
54668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54669       };
54670     } catch (std::exception& e) {
54671       {
54672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54673       };
54674     } catch (...) {
54675       {
54676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54677       };
54678     }
54679   }
54680   jresult = (int)result;
54681   return jresult;
54682 }
54683
54684
54685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
54686   int jresult ;
54687   int result;
54688
54689   {
54690     try {
54691       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
54692     } catch (std::out_of_range& e) {
54693       {
54694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54695       };
54696     } catch (std::exception& e) {
54697       {
54698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54699       };
54700     } catch (...) {
54701       {
54702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54703       };
54704     }
54705   }
54706   jresult = (int)result;
54707   return jresult;
54708 }
54709
54710
54711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
54712   int jresult ;
54713   int result;
54714
54715   {
54716     try {
54717       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
54718     } catch (std::out_of_range& e) {
54719       {
54720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54721       };
54722     } catch (std::exception& e) {
54723       {
54724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54725       };
54726     } catch (...) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54729       };
54730     }
54731   }
54732   jresult = (int)result;
54733   return jresult;
54734 }
54735
54736
54737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
54738   int jresult ;
54739   int result;
54740
54741   {
54742     try {
54743       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
54744     } catch (std::out_of_range& e) {
54745       {
54746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54747       };
54748     } catch (std::exception& e) {
54749       {
54750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54751       };
54752     } catch (...) {
54753       {
54754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54755       };
54756     }
54757   }
54758   jresult = (int)result;
54759   return jresult;
54760 }
54761
54762
54763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
54764   int jresult ;
54765   int result;
54766
54767   {
54768     try {
54769       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
54770     } catch (std::out_of_range& e) {
54771       {
54772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54773       };
54774     } catch (std::exception& e) {
54775       {
54776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54777       };
54778     } catch (...) {
54779       {
54780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54781       };
54782     }
54783   }
54784   jresult = (int)result;
54785   return jresult;
54786 }
54787
54788
54789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
54790   int jresult ;
54791   int result;
54792
54793   {
54794     try {
54795       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
54796     } catch (std::out_of_range& e) {
54797       {
54798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54799       };
54800     } catch (std::exception& e) {
54801       {
54802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54803       };
54804     } catch (...) {
54805       {
54806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54807       };
54808     }
54809   }
54810   jresult = (int)result;
54811   return jresult;
54812 }
54813
54814
54815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
54816   int jresult ;
54817   int result;
54818
54819   {
54820     try {
54821       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
54822     } catch (std::out_of_range& e) {
54823       {
54824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54825       };
54826     } catch (std::exception& e) {
54827       {
54828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54829       };
54830     } catch (...) {
54831       {
54832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54833       };
54834     }
54835   }
54836   jresult = (int)result;
54837   return jresult;
54838 }
54839
54840
54841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
54842   int jresult ;
54843   int result;
54844
54845   {
54846     try {
54847       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
54848     } catch (std::out_of_range& e) {
54849       {
54850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54851       };
54852     } catch (std::exception& e) {
54853       {
54854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54855       };
54856     } catch (...) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54859       };
54860     }
54861   }
54862   jresult = (int)result;
54863   return jresult;
54864 }
54865
54866
54867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
54868   int jresult ;
54869   int result;
54870
54871   {
54872     try {
54873       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
54874     } catch (std::out_of_range& e) {
54875       {
54876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (std::exception& e) {
54879       {
54880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54881       };
54882     } catch (...) {
54883       {
54884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54885       };
54886     }
54887   }
54888   jresult = (int)result;
54889   return jresult;
54890 }
54891
54892
54893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
54894   int jresult ;
54895   int result;
54896
54897   {
54898     try {
54899       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
54900     } catch (std::out_of_range& e) {
54901       {
54902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54903       };
54904     } catch (std::exception& e) {
54905       {
54906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54907       };
54908     } catch (...) {
54909       {
54910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54911       };
54912     }
54913   }
54914   jresult = (int)result;
54915   return jresult;
54916 }
54917
54918
54919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
54920   void * jresult ;
54921   Dali::Toolkit::Control result;
54922
54923   {
54924     try {
54925       result = Dali::Toolkit::Internal::Control::New();
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54937       };
54938     }
54939   }
54940   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
54946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54947   std::string *arg2 = 0 ;
54948
54949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54950   if (!jarg2) {
54951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54952     return ;
54953   }
54954   std::string arg2_str(jarg2);
54955   arg2 = &arg2_str;
54956   {
54957     try {
54958       (arg1)->SetStyleName((std::string const &)*arg2);
54959     } catch (std::out_of_range& e) {
54960       {
54961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54962       };
54963     } catch (std::exception& e) {
54964       {
54965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54966       };
54967     } catch (...) {
54968       {
54969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54970       };
54971     }
54972   }
54973
54974   //argout typemap for const std::string&
54975
54976 }
54977
54978
54979 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
54980   char * jresult ;
54981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
54982   std::string *result = 0 ;
54983
54984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
54985   {
54986     try {
54987       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
54988     } catch (std::out_of_range& e) {
54989       {
54990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54991       };
54992     } catch (std::exception& e) {
54993       {
54994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54995       };
54996     } catch (...) {
54997       {
54998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54999       };
55000     }
55001   }
55002   jresult = SWIG_csharp_string_callback(result->c_str());
55003   return jresult;
55004 }
55005
55006
55007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
55008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55009   Dali::Vector4 *arg2 = 0 ;
55010
55011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55012   arg2 = (Dali::Vector4 *)jarg2;
55013   if (!arg2) {
55014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
55015     return ;
55016   }
55017   {
55018     try {
55019       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
55020     } catch (std::out_of_range& e) {
55021       {
55022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55023       };
55024     } catch (std::exception& e) {
55025       {
55026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55027       };
55028     } catch (...) {
55029       {
55030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55031       };
55032     }
55033   }
55034 }
55035
55036
55037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
55038   void * jresult ;
55039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55040   Dali::Vector4 result;
55041
55042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55043   {
55044     try {
55045       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
55046     } catch (std::out_of_range& e) {
55047       {
55048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55049       };
55050     } catch (std::exception& e) {
55051       {
55052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55053       };
55054     } catch (...) {
55055       {
55056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55057       };
55058     }
55059   }
55060   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
55061   return jresult;
55062 }
55063
55064
55065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
55066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55067   Dali::Image arg2 ;
55068   Dali::Image *argp2 ;
55069
55070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55071   argp2 = (Dali::Image *)jarg2;
55072   if (!argp2) {
55073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
55074     return ;
55075   }
55076   arg2 = *argp2;
55077   {
55078     try {
55079       (arg1)->SetBackgroundImage(arg2);
55080     } catch (std::out_of_range& e) {
55081       {
55082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55083       };
55084     } catch (std::exception& e) {
55085       {
55086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55087       };
55088     } catch (...) {
55089       {
55090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55091       };
55092     }
55093   }
55094 }
55095
55096
55097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
55098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55099   Dali::Property::Map *arg2 = 0 ;
55100
55101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55102   arg2 = (Dali::Property::Map *)jarg2;
55103   if (!arg2) {
55104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55105     return ;
55106   }
55107   {
55108     try {
55109       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
55110     } catch (std::out_of_range& e) {
55111       {
55112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (std::exception& e) {
55115       {
55116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55117       };
55118     } catch (...) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55121       };
55122     }
55123   }
55124 }
55125
55126
55127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
55128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55129
55130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55131   {
55132     try {
55133       (arg1)->ClearBackground();
55134     } catch (std::out_of_range& e) {
55135       {
55136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55137       };
55138     } catch (std::exception& e) {
55139       {
55140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55141       };
55142     } catch (...) {
55143       {
55144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55145       };
55146     }
55147   }
55148 }
55149
55150
55151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
55152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55153   Dali::Gesture::Type arg2 ;
55154
55155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55156   arg2 = (Dali::Gesture::Type)jarg2;
55157   {
55158     try {
55159       (arg1)->EnableGestureDetection(arg2);
55160     } catch (std::out_of_range& e) {
55161       {
55162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55163       };
55164     } catch (std::exception& e) {
55165       {
55166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55167       };
55168     } catch (...) {
55169       {
55170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55171       };
55172     }
55173   }
55174 }
55175
55176
55177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
55178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55179   Dali::Gesture::Type arg2 ;
55180
55181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55182   arg2 = (Dali::Gesture::Type)jarg2;
55183   {
55184     try {
55185       (arg1)->DisableGestureDetection(arg2);
55186     } catch (std::out_of_range& e) {
55187       {
55188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55189       };
55190     } catch (std::exception& e) {
55191       {
55192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55193       };
55194     } catch (...) {
55195       {
55196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55197       };
55198     }
55199   }
55200 }
55201
55202
55203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
55204   void * jresult ;
55205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55206   Dali::PinchGestureDetector result;
55207
55208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55209   {
55210     try {
55211       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
55212     } catch (std::out_of_range& e) {
55213       {
55214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55215       };
55216     } catch (std::exception& e) {
55217       {
55218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55219       };
55220     } catch (...) {
55221       {
55222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55223       };
55224     }
55225   }
55226   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
55227   return jresult;
55228 }
55229
55230
55231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
55232   void * jresult ;
55233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55234   Dali::PanGestureDetector result;
55235
55236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55237   {
55238     try {
55239       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
55240     } catch (std::out_of_range& e) {
55241       {
55242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55243       };
55244     } catch (std::exception& e) {
55245       {
55246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55247       };
55248     } catch (...) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55251       };
55252     }
55253   }
55254   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
55255   return jresult;
55256 }
55257
55258
55259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
55260   void * jresult ;
55261   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55262   Dali::TapGestureDetector result;
55263
55264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55265   {
55266     try {
55267       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
55268     } catch (std::out_of_range& e) {
55269       {
55270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55271       };
55272     } catch (std::exception& e) {
55273       {
55274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55275       };
55276     } catch (...) {
55277       {
55278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55279       };
55280     }
55281   }
55282   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
55283   return jresult;
55284 }
55285
55286
55287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
55288   void * jresult ;
55289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55290   Dali::LongPressGestureDetector result;
55291
55292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55293   {
55294     try {
55295       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
55296     } catch (std::out_of_range& e) {
55297       {
55298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55299       };
55300     } catch (std::exception& e) {
55301       {
55302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55303       };
55304     } catch (...) {
55305       {
55306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55307       };
55308     }
55309   }
55310   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
55311   return jresult;
55312 }
55313
55314
55315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
55316   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55317   bool arg2 ;
55318
55319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55320   arg2 = jarg2 ? true : false;
55321   {
55322     try {
55323       (arg1)->SetKeyboardNavigationSupport(arg2);
55324     } catch (std::out_of_range& e) {
55325       {
55326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55327       };
55328     } catch (std::exception& e) {
55329       {
55330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55331       };
55332     } catch (...) {
55333       {
55334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55335       };
55336     }
55337   }
55338 }
55339
55340
55341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
55342   unsigned int jresult ;
55343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55344   bool result;
55345
55346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55347   {
55348     try {
55349       result = (bool)(arg1)->IsKeyboardNavigationSupported();
55350     } catch (std::out_of_range& e) {
55351       {
55352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55353       };
55354     } catch (std::exception& e) {
55355       {
55356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55357       };
55358     } catch (...) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55361       };
55362     }
55363   }
55364   jresult = result;
55365   return jresult;
55366 }
55367
55368
55369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
55370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55371
55372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55373   {
55374     try {
55375       (arg1)->SetKeyInputFocus();
55376     } catch (std::out_of_range& e) {
55377       {
55378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55379       };
55380     } catch (std::exception& e) {
55381       {
55382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55383       };
55384     } catch (...) {
55385       {
55386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55387       };
55388     }
55389   }
55390 }
55391
55392
55393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
55394   unsigned int jresult ;
55395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55396   bool result;
55397
55398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55399   {
55400     try {
55401       result = (bool)(arg1)->HasKeyInputFocus();
55402     } catch (std::out_of_range& e) {
55403       {
55404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55405       };
55406     } catch (std::exception& e) {
55407       {
55408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55409       };
55410     } catch (...) {
55411       {
55412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55413       };
55414     }
55415   }
55416   jresult = result;
55417   return jresult;
55418 }
55419
55420
55421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
55422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55423
55424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55425   {
55426     try {
55427       (arg1)->ClearKeyInputFocus();
55428     } catch (std::out_of_range& e) {
55429       {
55430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55431       };
55432     } catch (std::exception& e) {
55433       {
55434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55435       };
55436     } catch (...) {
55437       {
55438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55439       };
55440     }
55441   }
55442 }
55443
55444
55445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
55446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55447   bool arg2 ;
55448
55449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55450   arg2 = jarg2 ? true : false;
55451   {
55452     try {
55453       (arg1)->SetAsKeyboardFocusGroup(arg2);
55454     } catch (std::out_of_range& e) {
55455       {
55456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55457       };
55458     } catch (std::exception& e) {
55459       {
55460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55461       };
55462     } catch (...) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55465       };
55466     }
55467   }
55468 }
55469
55470
55471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
55472   unsigned int jresult ;
55473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55474   bool result;
55475
55476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55477   {
55478     try {
55479       result = (bool)(arg1)->IsKeyboardFocusGroup();
55480     } catch (std::out_of_range& e) {
55481       {
55482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55483       };
55484     } catch (std::exception& e) {
55485       {
55486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55487       };
55488     } catch (...) {
55489       {
55490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55491       };
55492     }
55493   }
55494   jresult = result;
55495   return jresult;
55496 }
55497
55498
55499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
55500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55501
55502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55503   {
55504     try {
55505       (arg1)->AccessibilityActivate();
55506     } catch (std::out_of_range& e) {
55507       {
55508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55509       };
55510     } catch (std::exception& e) {
55511       {
55512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55513       };
55514     } catch (...) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55517       };
55518     }
55519   }
55520 }
55521
55522
55523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
55524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55525
55526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55527   {
55528     try {
55529       (arg1)->KeyboardEnter();
55530     } catch (std::out_of_range& e) {
55531       {
55532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55533       };
55534     } catch (std::exception& e) {
55535       {
55536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55537       };
55538     } catch (...) {
55539       {
55540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55541       };
55542     }
55543   }
55544 }
55545
55546
55547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
55548   void * jresult ;
55549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55550   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
55551
55552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55553   {
55554     try {
55555       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
55556     } catch (std::out_of_range& e) {
55557       {
55558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55559       };
55560     } catch (std::exception& e) {
55561       {
55562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55563       };
55564     } catch (...) {
55565       {
55566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55567       };
55568     }
55569   }
55570   jresult = (void *)result;
55571   return jresult;
55572 }
55573
55574
55575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
55576   void * jresult ;
55577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55578   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55579
55580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55581   {
55582     try {
55583       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
55584     } catch (std::out_of_range& e) {
55585       {
55586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55587       };
55588     } catch (std::exception& e) {
55589       {
55590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55591       };
55592     } catch (...) {
55593       {
55594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55595       };
55596     }
55597   }
55598   jresult = (void *)result;
55599   return jresult;
55600 }
55601
55602
55603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
55604   void * jresult ;
55605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55606   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
55607
55608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55609   {
55610     try {
55611       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
55612     } catch (std::out_of_range& e) {
55613       {
55614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55615       };
55616     } catch (std::exception& e) {
55617       {
55618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55619       };
55620     } catch (...) {
55621       {
55622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55623       };
55624     }
55625   }
55626   jresult = (void *)result;
55627   return jresult;
55628 }
55629
55630
55631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
55632   unsigned int jresult ;
55633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55634   Dali::KeyEvent *arg2 = 0 ;
55635   bool result;
55636
55637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55638   arg2 = (Dali::KeyEvent *)jarg2;
55639   if (!arg2) {
55640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55641     return 0;
55642   }
55643   {
55644     try {
55645       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
55646     } catch (std::out_of_range& e) {
55647       {
55648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55649       };
55650     } catch (std::exception& e) {
55651       {
55652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55653       };
55654     } catch (...) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55657       };
55658     }
55659   }
55660   jresult = result;
55661   return jresult;
55662 }
55663
55664
55665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
55666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55667   int arg2 ;
55668   SwigDirector_ViewImpl *darg = 0;
55669
55670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55671   arg2 = (int)jarg2;
55672   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55673   {
55674     try {
55675       (darg)->OnStageConnection(arg2);
55676     } catch (std::out_of_range& e) {
55677       {
55678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55679       };
55680     } catch (std::exception& e) {
55681       {
55682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55683       };
55684     } catch (...) {
55685       {
55686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55687       };
55688     }
55689   }
55690 }
55691
55692
55693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
55694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55695   int arg2 ;
55696   SwigDirector_ViewImpl *darg = 0;
55697
55698   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55699   arg2 = (int)jarg2;
55700   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55701   {
55702     try {
55703       (darg)->OnStageConnectionSwigPublic(arg2);
55704     } catch (std::out_of_range& e) {
55705       {
55706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55707       };
55708     } catch (std::exception& e) {
55709       {
55710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55711       };
55712     } catch (...) {
55713       {
55714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55715       };
55716     }
55717   }
55718 }
55719
55720
55721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
55722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55723   SwigDirector_ViewImpl *darg = 0;
55724
55725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55726   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55727   {
55728     try {
55729       (darg)->OnStageDisconnection();
55730     } catch (std::out_of_range& e) {
55731       {
55732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55733       };
55734     } catch (std::exception& e) {
55735       {
55736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55737       };
55738     } catch (...) {
55739       {
55740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55741       };
55742     }
55743   }
55744 }
55745
55746
55747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
55748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55749   SwigDirector_ViewImpl *darg = 0;
55750
55751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55752   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55753   {
55754     try {
55755       (darg)->OnStageDisconnectionSwigPublic();
55756     } catch (std::out_of_range& e) {
55757       {
55758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55759       };
55760     } catch (std::exception& e) {
55761       {
55762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55763       };
55764     } catch (...) {
55765       {
55766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55767       };
55768     }
55769   }
55770 }
55771
55772
55773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
55774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55775   Dali::Actor *arg2 = 0 ;
55776   SwigDirector_ViewImpl *darg = 0;
55777
55778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55779   arg2 = (Dali::Actor *)jarg2;
55780   if (!arg2) {
55781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55782     return ;
55783   }
55784   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55785   {
55786     try {
55787       (darg)->OnChildAdd(*arg2);
55788     } catch (std::out_of_range& e) {
55789       {
55790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55791       };
55792     } catch (std::exception& e) {
55793       {
55794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55795       };
55796     } catch (...) {
55797       {
55798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55799       };
55800     }
55801   }
55802 }
55803
55804
55805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55807   Dali::Actor *arg2 = 0 ;
55808   SwigDirector_ViewImpl *darg = 0;
55809
55810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55811   arg2 = (Dali::Actor *)jarg2;
55812   if (!arg2) {
55813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55814     return ;
55815   }
55816   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55817   {
55818     try {
55819       (darg)->OnChildAddSwigPublic(*arg2);
55820     } catch (std::out_of_range& e) {
55821       {
55822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55823       };
55824     } catch (std::exception& e) {
55825       {
55826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55827       };
55828     } catch (...) {
55829       {
55830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55831       };
55832     }
55833   }
55834 }
55835
55836
55837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
55838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55839   Dali::Actor *arg2 = 0 ;
55840   SwigDirector_ViewImpl *darg = 0;
55841
55842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55843   arg2 = (Dali::Actor *)jarg2;
55844   if (!arg2) {
55845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55846     return ;
55847   }
55848   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55849   {
55850     try {
55851       (darg)->OnChildRemove(*arg2);
55852     } catch (std::out_of_range& e) {
55853       {
55854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55855       };
55856     } catch (std::exception& e) {
55857       {
55858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55859       };
55860     } catch (...) {
55861       {
55862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55863       };
55864     }
55865   }
55866 }
55867
55868
55869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
55870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55871   Dali::Actor *arg2 = 0 ;
55872   SwigDirector_ViewImpl *darg = 0;
55873
55874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55875   arg2 = (Dali::Actor *)jarg2;
55876   if (!arg2) {
55877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
55878     return ;
55879   }
55880   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55881   {
55882     try {
55883       (darg)->OnChildRemoveSwigPublic(*arg2);
55884     } catch (std::out_of_range& e) {
55885       {
55886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55887       };
55888     } catch (std::exception& e) {
55889       {
55890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55891       };
55892     } catch (...) {
55893       {
55894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55895       };
55896     }
55897   }
55898 }
55899
55900
55901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
55902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55903   Dali::Property::Index arg2 ;
55904   Dali::Property::Value arg3 ;
55905   Dali::Property::Value *argp3 ;
55906   SwigDirector_ViewImpl *darg = 0;
55907
55908   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55909   arg2 = (Dali::Property::Index)jarg2;
55910   argp3 = (Dali::Property::Value *)jarg3;
55911   if (!argp3) {
55912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55913     return ;
55914   }
55915   arg3 = *argp3;
55916   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55917   {
55918     try {
55919       (darg)->OnPropertySet(arg2,arg3);
55920     } catch (std::out_of_range& e) {
55921       {
55922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55923       };
55924     } catch (std::exception& e) {
55925       {
55926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55927       };
55928     } catch (...) {
55929       {
55930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55931       };
55932     }
55933   }
55934 }
55935
55936
55937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
55938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55939   Dali::Property::Index arg2 ;
55940   Dali::Property::Value arg3 ;
55941   Dali::Property::Value *argp3 ;
55942   SwigDirector_ViewImpl *darg = 0;
55943
55944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55945   arg2 = (Dali::Property::Index)jarg2;
55946   argp3 = (Dali::Property::Value *)jarg3;
55947   if (!argp3) {
55948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
55949     return ;
55950   }
55951   arg3 = *argp3;
55952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55953   {
55954     try {
55955       (darg)->OnPropertySetSwigPublic(arg2,arg3);
55956     } catch (std::out_of_range& e) {
55957       {
55958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55959       };
55960     } catch (std::exception& e) {
55961       {
55962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55963       };
55964     } catch (...) {
55965       {
55966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55967       };
55968     }
55969   }
55970 }
55971
55972
55973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
55974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
55975   Dali::Vector3 *arg2 = 0 ;
55976   SwigDirector_ViewImpl *darg = 0;
55977
55978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
55979   arg2 = (Dali::Vector3 *)jarg2;
55980   if (!arg2) {
55981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
55982     return ;
55983   }
55984   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
55985   {
55986     try {
55987       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
55988     } catch (std::out_of_range& e) {
55989       {
55990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55991       };
55992     } catch (std::exception& e) {
55993       {
55994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55995       };
55996     } catch (...) {
55997       {
55998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55999       };
56000     }
56001   }
56002 }
56003
56004
56005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56007   Dali::Vector3 *arg2 = 0 ;
56008   SwigDirector_ViewImpl *darg = 0;
56009
56010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56011   arg2 = (Dali::Vector3 *)jarg2;
56012   if (!arg2) {
56013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
56014     return ;
56015   }
56016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56017   {
56018     try {
56019       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
56020     } catch (std::out_of_range& e) {
56021       {
56022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56023       };
56024     } catch (std::exception& e) {
56025       {
56026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56027       };
56028     } catch (...) {
56029       {
56030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56031       };
56032     }
56033   }
56034 }
56035
56036
56037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
56038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56039   Dali::Animation *arg2 = 0 ;
56040   Dali::Vector3 *arg3 = 0 ;
56041   SwigDirector_ViewImpl *darg = 0;
56042
56043   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56044   arg2 = (Dali::Animation *)jarg2;
56045   if (!arg2) {
56046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
56047     return ;
56048   }
56049   arg3 = (Dali::Vector3 *)jarg3;
56050   if (!arg3) {
56051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
56052     return ;
56053   }
56054   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56055   {
56056     try {
56057       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
56058     } catch (std::out_of_range& e) {
56059       {
56060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56061       };
56062     } catch (std::exception& e) {
56063       {
56064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56065       };
56066     } catch (...) {
56067       {
56068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56069       };
56070     }
56071   }
56072 }
56073
56074
56075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56076   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56077   Dali::Animation *arg2 = 0 ;
56078   Dali::Vector3 *arg3 = 0 ;
56079   SwigDirector_ViewImpl *darg = 0;
56080
56081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56082   arg2 = (Dali::Animation *)jarg2;
56083   if (!arg2) {
56084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
56085     return ;
56086   }
56087   arg3 = (Dali::Vector3 *)jarg3;
56088   if (!arg3) {
56089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
56090     return ;
56091   }
56092   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56093   {
56094     try {
56095       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
56096     } catch (std::out_of_range& e) {
56097       {
56098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56099       };
56100     } catch (std::exception& e) {
56101       {
56102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56103       };
56104     } catch (...) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56107       };
56108     }
56109   }
56110 }
56111
56112
56113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
56114   unsigned int jresult ;
56115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56116   Dali::TouchEvent *arg2 = 0 ;
56117   SwigDirector_ViewImpl *darg = 0;
56118   bool result;
56119
56120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56121   arg2 = (Dali::TouchEvent *)jarg2;
56122   if (!arg2) {
56123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56124     return 0;
56125   }
56126   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56127   {
56128     try {
56129       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
56130     } catch (std::out_of_range& e) {
56131       {
56132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56133       };
56134     } catch (std::exception& e) {
56135       {
56136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56137       };
56138     } catch (...) {
56139       {
56140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56141       };
56142     }
56143   }
56144   jresult = result;
56145   return jresult;
56146 }
56147
56148
56149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56150   unsigned int jresult ;
56151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56152   Dali::TouchEvent *arg2 = 0 ;
56153   SwigDirector_ViewImpl *darg = 0;
56154   bool result;
56155
56156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56157   arg2 = (Dali::TouchEvent *)jarg2;
56158   if (!arg2) {
56159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
56160     return 0;
56161   }
56162   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56163   {
56164     try {
56165       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
56166     } catch (std::out_of_range& e) {
56167       {
56168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56169       };
56170     } catch (std::exception& e) {
56171       {
56172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56173       };
56174     } catch (...) {
56175       {
56176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56177       };
56178     }
56179   }
56180   jresult = result;
56181   return jresult;
56182 }
56183
56184
56185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
56186   unsigned int jresult ;
56187   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56188   Dali::HoverEvent *arg2 = 0 ;
56189   SwigDirector_ViewImpl *darg = 0;
56190   bool result;
56191
56192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56193   arg2 = (Dali::HoverEvent *)jarg2;
56194   if (!arg2) {
56195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56196     return 0;
56197   }
56198   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56199   {
56200     try {
56201       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
56202     } catch (std::out_of_range& e) {
56203       {
56204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56205       };
56206     } catch (std::exception& e) {
56207       {
56208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56209       };
56210     } catch (...) {
56211       {
56212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56213       };
56214     }
56215   }
56216   jresult = result;
56217   return jresult;
56218 }
56219
56220
56221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56222   unsigned int jresult ;
56223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56224   Dali::HoverEvent *arg2 = 0 ;
56225   SwigDirector_ViewImpl *darg = 0;
56226   bool result;
56227
56228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56229   arg2 = (Dali::HoverEvent *)jarg2;
56230   if (!arg2) {
56231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
56232     return 0;
56233   }
56234   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56235   {
56236     try {
56237       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
56238     } catch (std::out_of_range& e) {
56239       {
56240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (std::exception& e) {
56243       {
56244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56245       };
56246     } catch (...) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56249       };
56250     }
56251   }
56252   jresult = result;
56253   return jresult;
56254 }
56255
56256
56257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
56258   unsigned int jresult ;
56259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56260   Dali::KeyEvent *arg2 = 0 ;
56261   SwigDirector_ViewImpl *darg = 0;
56262   bool result;
56263
56264   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56265   arg2 = (Dali::KeyEvent *)jarg2;
56266   if (!arg2) {
56267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56268     return 0;
56269   }
56270   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56271   {
56272     try {
56273       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
56274     } catch (std::out_of_range& e) {
56275       {
56276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56277       };
56278     } catch (std::exception& e) {
56279       {
56280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56281       };
56282     } catch (...) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56285       };
56286     }
56287   }
56288   jresult = result;
56289   return jresult;
56290 }
56291
56292
56293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56294   unsigned int jresult ;
56295   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56296   Dali::KeyEvent *arg2 = 0 ;
56297   SwigDirector_ViewImpl *darg = 0;
56298   bool result;
56299
56300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56301   arg2 = (Dali::KeyEvent *)jarg2;
56302   if (!arg2) {
56303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56304     return 0;
56305   }
56306   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56307   {
56308     try {
56309       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
56310     } catch (std::out_of_range& e) {
56311       {
56312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56313       };
56314     } catch (std::exception& e) {
56315       {
56316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56317       };
56318     } catch (...) {
56319       {
56320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56321       };
56322     }
56323   }
56324   jresult = result;
56325   return jresult;
56326 }
56327
56328
56329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
56330   unsigned int jresult ;
56331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56332   Dali::WheelEvent *arg2 = 0 ;
56333   SwigDirector_ViewImpl *darg = 0;
56334   bool result;
56335
56336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56337   arg2 = (Dali::WheelEvent *)jarg2;
56338   if (!arg2) {
56339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56340     return 0;
56341   }
56342   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56343   {
56344     try {
56345       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
56346     } catch (std::out_of_range& e) {
56347       {
56348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56349       };
56350     } catch (std::exception& e) {
56351       {
56352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56353       };
56354     } catch (...) {
56355       {
56356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56357       };
56358     }
56359   }
56360   jresult = result;
56361   return jresult;
56362 }
56363
56364
56365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
56366   unsigned int jresult ;
56367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56368   Dali::WheelEvent *arg2 = 0 ;
56369   SwigDirector_ViewImpl *darg = 0;
56370   bool result;
56371
56372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56373   arg2 = (Dali::WheelEvent *)jarg2;
56374   if (!arg2) {
56375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56376     return 0;
56377   }
56378   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56379   {
56380     try {
56381       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
56382     } catch (std::out_of_range& e) {
56383       {
56384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56385       };
56386     } catch (std::exception& e) {
56387       {
56388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56389       };
56390     } catch (...) {
56391       {
56392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56393       };
56394     }
56395   }
56396   jresult = result;
56397   return jresult;
56398 }
56399
56400
56401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
56402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56403   Dali::Vector2 *arg2 = 0 ;
56404   Dali::RelayoutContainer *arg3 = 0 ;
56405   SwigDirector_ViewImpl *darg = 0;
56406
56407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56408   arg2 = (Dali::Vector2 *)jarg2;
56409   if (!arg2) {
56410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56411     return ;
56412   }
56413   arg3 = (Dali::RelayoutContainer *)jarg3;
56414   if (!arg3) {
56415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56416     return ;
56417   }
56418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56419   {
56420     try {
56421       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
56422     } catch (std::out_of_range& e) {
56423       {
56424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56425       };
56426     } catch (std::exception& e) {
56427       {
56428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56429       };
56430     } catch (...) {
56431       {
56432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56433       };
56434     }
56435   }
56436 }
56437
56438
56439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
56440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56441   Dali::Vector2 *arg2 = 0 ;
56442   Dali::RelayoutContainer *arg3 = 0 ;
56443   SwigDirector_ViewImpl *darg = 0;
56444
56445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56446   arg2 = (Dali::Vector2 *)jarg2;
56447   if (!arg2) {
56448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
56449     return ;
56450   }
56451   arg3 = (Dali::RelayoutContainer *)jarg3;
56452   if (!arg3) {
56453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
56454     return ;
56455   }
56456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56457   {
56458     try {
56459       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
56460     } catch (std::out_of_range& e) {
56461       {
56462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56463       };
56464     } catch (std::exception& e) {
56465       {
56466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56467       };
56468     } catch (...) {
56469       {
56470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56471       };
56472     }
56473   }
56474 }
56475
56476
56477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
56478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56479   Dali::ResizePolicy::Type arg2 ;
56480   Dali::Dimension::Type arg3 ;
56481   SwigDirector_ViewImpl *darg = 0;
56482
56483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56484   arg2 = (Dali::ResizePolicy::Type)jarg2;
56485   arg3 = (Dali::Dimension::Type)jarg3;
56486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56487   {
56488     try {
56489       (darg)->OnSetResizePolicy(arg2,arg3);
56490     } catch (std::out_of_range& e) {
56491       {
56492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56493       };
56494     } catch (std::exception& e) {
56495       {
56496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (...) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56501       };
56502     }
56503   }
56504 }
56505
56506
56507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
56508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56509   Dali::ResizePolicy::Type arg2 ;
56510   Dali::Dimension::Type arg3 ;
56511   SwigDirector_ViewImpl *darg = 0;
56512
56513   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56514   arg2 = (Dali::ResizePolicy::Type)jarg2;
56515   arg3 = (Dali::Dimension::Type)jarg3;
56516   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56517   {
56518     try {
56519       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
56520     } catch (std::out_of_range& e) {
56521       {
56522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56523       };
56524     } catch (std::exception& e) {
56525       {
56526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56531       };
56532     }
56533   }
56534 }
56535
56536
56537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
56538   void * jresult ;
56539   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56540   SwigDirector_ViewImpl *darg = 0;
56541   Dali::Vector3 result;
56542
56543   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56545   {
56546     try {
56547       result = (darg)->GetNaturalSize();
56548     } catch (std::out_of_range& e) {
56549       {
56550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56551       };
56552     } catch (std::exception& e) {
56553       {
56554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56555       };
56556     } catch (...) {
56557       {
56558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56559       };
56560     }
56561   }
56562   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56563   return jresult;
56564 }
56565
56566
56567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
56568   void * jresult ;
56569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56570   SwigDirector_ViewImpl *darg = 0;
56571   Dali::Vector3 result;
56572
56573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56574   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56575   {
56576     try {
56577       result = (darg)->GetNaturalSizeSwigPublic();
56578     } catch (std::out_of_range& e) {
56579       {
56580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56581       };
56582     } catch (std::exception& e) {
56583       {
56584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56585       };
56586     } catch (...) {
56587       {
56588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56589       };
56590     }
56591   }
56592   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
56593   return jresult;
56594 }
56595
56596
56597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
56598   float jresult ;
56599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56600   Dali::Actor *arg2 = 0 ;
56601   Dali::Dimension::Type arg3 ;
56602   SwigDirector_ViewImpl *darg = 0;
56603   float result;
56604
56605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56606   arg2 = (Dali::Actor *)jarg2;
56607   if (!arg2) {
56608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56609     return 0;
56610   }
56611   arg3 = (Dali::Dimension::Type)jarg3;
56612   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56613   {
56614     try {
56615       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56623       };
56624     } catch (...) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56627       };
56628     }
56629   }
56630   jresult = result;
56631   return jresult;
56632 }
56633
56634
56635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
56636   float jresult ;
56637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56638   Dali::Actor *arg2 = 0 ;
56639   Dali::Dimension::Type arg3 ;
56640   SwigDirector_ViewImpl *darg = 0;
56641   float result;
56642
56643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56644   arg2 = (Dali::Actor *)jarg2;
56645   if (!arg2) {
56646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
56647     return 0;
56648   }
56649   arg3 = (Dali::Dimension::Type)jarg3;
56650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56651   {
56652     try {
56653       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
56654     } catch (std::out_of_range& e) {
56655       {
56656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56657       };
56658     } catch (std::exception& e) {
56659       {
56660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56665       };
56666     }
56667   }
56668   jresult = result;
56669   return jresult;
56670 }
56671
56672
56673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
56674   float jresult ;
56675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56676   float arg2 ;
56677   SwigDirector_ViewImpl *darg = 0;
56678   float result;
56679
56680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56681   arg2 = (float)jarg2;
56682   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56683   {
56684     try {
56685       result = (float)(darg)->GetHeightForWidth(arg2);
56686     } catch (std::out_of_range& e) {
56687       {
56688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56689       };
56690     } catch (std::exception& e) {
56691       {
56692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56693       };
56694     } catch (...) {
56695       {
56696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56697       };
56698     }
56699   }
56700   jresult = result;
56701   return jresult;
56702 }
56703
56704
56705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
56706   float jresult ;
56707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56708   float arg2 ;
56709   SwigDirector_ViewImpl *darg = 0;
56710   float result;
56711
56712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56713   arg2 = (float)jarg2;
56714   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56715   {
56716     try {
56717       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
56718     } catch (std::out_of_range& e) {
56719       {
56720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (std::exception& e) {
56723       {
56724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (...) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56729       };
56730     }
56731   }
56732   jresult = result;
56733   return jresult;
56734 }
56735
56736
56737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
56738   float jresult ;
56739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56740   float arg2 ;
56741   SwigDirector_ViewImpl *darg = 0;
56742   float result;
56743
56744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56745   arg2 = (float)jarg2;
56746   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56747   {
56748     try {
56749       result = (float)(darg)->GetWidthForHeight(arg2);
56750     } catch (std::out_of_range& e) {
56751       {
56752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (std::exception& e) {
56755       {
56756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56757       };
56758     } catch (...) {
56759       {
56760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56761       };
56762     }
56763   }
56764   jresult = result;
56765   return jresult;
56766 }
56767
56768
56769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
56770   float jresult ;
56771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56772   float arg2 ;
56773   SwigDirector_ViewImpl *darg = 0;
56774   float result;
56775
56776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56777   arg2 = (float)jarg2;
56778   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56779   {
56780     try {
56781       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
56782     } catch (std::out_of_range& e) {
56783       {
56784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56785       };
56786     } catch (std::exception& e) {
56787       {
56788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56789       };
56790     } catch (...) {
56791       {
56792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56793       };
56794     }
56795   }
56796   jresult = result;
56797   return jresult;
56798 }
56799
56800
56801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
56802   unsigned int jresult ;
56803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56804   Dali::Dimension::Type arg2 ;
56805   SwigDirector_ViewImpl *darg = 0;
56806   bool result;
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       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
56814     } catch (std::out_of_range& e) {
56815       {
56816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56817       };
56818     } catch (std::exception& e) {
56819       {
56820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56821       };
56822     } catch (...) {
56823       {
56824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56825       };
56826     }
56827   }
56828   jresult = result;
56829   return jresult;
56830 }
56831
56832
56833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
56834   unsigned int jresult ;
56835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56836   Dali::Dimension::Type arg2 ;
56837   SwigDirector_ViewImpl *darg = 0;
56838   bool result;
56839
56840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56841   arg2 = (Dali::Dimension::Type)jarg2;
56842   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56843   {
56844     try {
56845       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
56846     } catch (std::out_of_range& e) {
56847       {
56848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56849       };
56850     } catch (std::exception& e) {
56851       {
56852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (...) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56857       };
56858     }
56859   }
56860   jresult = result;
56861   return jresult;
56862 }
56863
56864
56865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
56866   unsigned int jresult ;
56867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56868   SwigDirector_ViewImpl *darg = 0;
56869   bool result;
56870
56871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56872   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56873   {
56874     try {
56875       result = (bool)(darg)->RelayoutDependentOnChildren();
56876     } catch (std::out_of_range& e) {
56877       {
56878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56879       };
56880     } catch (std::exception& e) {
56881       {
56882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56883       };
56884     } catch (...) {
56885       {
56886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56887       };
56888     }
56889   }
56890   jresult = result;
56891   return jresult;
56892 }
56893
56894
56895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
56896   unsigned int jresult ;
56897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56898   SwigDirector_ViewImpl *darg = 0;
56899   bool result;
56900
56901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56902   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56903   {
56904     try {
56905       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
56906     } catch (std::out_of_range& e) {
56907       {
56908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56909       };
56910     } catch (std::exception& e) {
56911       {
56912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (...) {
56915       {
56916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56917       };
56918     }
56919   }
56920   jresult = result;
56921   return jresult;
56922 }
56923
56924
56925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
56926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56927   Dali::Dimension::Type arg2 ;
56928   SwigDirector_ViewImpl *darg = 0;
56929
56930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56931   arg2 = (Dali::Dimension::Type)jarg2;
56932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56933   {
56934     try {
56935       (darg)->OnCalculateRelayoutSize(arg2);
56936     } catch (std::out_of_range& e) {
56937       {
56938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56939       };
56940     } catch (std::exception& e) {
56941       {
56942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56943       };
56944     } catch (...) {
56945       {
56946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56947       };
56948     }
56949   }
56950 }
56951
56952
56953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
56954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56955   Dali::Dimension::Type arg2 ;
56956   SwigDirector_ViewImpl *darg = 0;
56957
56958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56959   arg2 = (Dali::Dimension::Type)jarg2;
56960   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56961   {
56962     try {
56963       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
56964     } catch (std::out_of_range& e) {
56965       {
56966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56967       };
56968     } catch (std::exception& e) {
56969       {
56970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56971       };
56972     } catch (...) {
56973       {
56974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56975       };
56976     }
56977   }
56978 }
56979
56980
56981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
56982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
56983   float arg2 ;
56984   Dali::Dimension::Type arg3 ;
56985   SwigDirector_ViewImpl *darg = 0;
56986
56987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
56988   arg2 = (float)jarg2;
56989   arg3 = (Dali::Dimension::Type)jarg3;
56990   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
56991   {
56992     try {
56993       (darg)->OnLayoutNegotiated(arg2,arg3);
56994     } catch (std::out_of_range& e) {
56995       {
56996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56997       };
56998     } catch (std::exception& e) {
56999       {
57000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57001       };
57002     } catch (...) {
57003       {
57004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57005       };
57006     }
57007   }
57008 }
57009
57010
57011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
57012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57013   float arg2 ;
57014   Dali::Dimension::Type arg3 ;
57015   SwigDirector_ViewImpl *darg = 0;
57016
57017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57018   arg2 = (float)jarg2;
57019   arg3 = (Dali::Dimension::Type)jarg3;
57020   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57021   {
57022     try {
57023       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
57024     } catch (std::out_of_range& e) {
57025       {
57026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57027       };
57028     } catch (std::exception& e) {
57029       {
57030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57031       };
57032     } catch (...) {
57033       {
57034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57035       };
57036     }
57037   }
57038 }
57039
57040
57041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
57042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57043
57044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57045   {
57046     try {
57047       (arg1)->OnInitialize();
57048     } catch (std::out_of_range& e) {
57049       {
57050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57051       };
57052     } catch (std::exception& e) {
57053       {
57054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57055       };
57056     } catch (...) {
57057       {
57058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57059       };
57060     }
57061   }
57062 }
57063
57064
57065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
57066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57067
57068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57069   {
57070     try {
57071       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
57072     } catch (std::out_of_range& e) {
57073       {
57074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57075       };
57076     } catch (std::exception& e) {
57077       {
57078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57079       };
57080     } catch (...) {
57081       {
57082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57083       };
57084     }
57085   }
57086 }
57087
57088
57089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
57090   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57091   Dali::Actor *arg2 = 0 ;
57092
57093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57094   arg2 = (Dali::Actor *)jarg2;
57095   if (!arg2) {
57096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57097     return ;
57098   }
57099   {
57100     try {
57101       (arg1)->OnControlChildAdd(*arg2);
57102     } catch (std::out_of_range& e) {
57103       {
57104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57105       };
57106     } catch (std::exception& e) {
57107       {
57108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57109       };
57110     } catch (...) {
57111       {
57112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57113       };
57114     }
57115   }
57116 }
57117
57118
57119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57121   Dali::Actor *arg2 = 0 ;
57122
57123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57124   arg2 = (Dali::Actor *)jarg2;
57125   if (!arg2) {
57126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57127     return ;
57128   }
57129   {
57130     try {
57131       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
57132     } catch (std::out_of_range& e) {
57133       {
57134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57135       };
57136     } catch (std::exception& e) {
57137       {
57138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57139       };
57140     } catch (...) {
57141       {
57142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57143       };
57144     }
57145   }
57146 }
57147
57148
57149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
57150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57151   Dali::Actor *arg2 = 0 ;
57152
57153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57154   arg2 = (Dali::Actor *)jarg2;
57155   if (!arg2) {
57156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57157     return ;
57158   }
57159   {
57160     try {
57161       (arg1)->OnControlChildRemove(*arg2);
57162     } catch (std::out_of_range& e) {
57163       {
57164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57165       };
57166     } catch (std::exception& e) {
57167       {
57168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57173       };
57174     }
57175   }
57176 }
57177
57178
57179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57180   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57181   Dali::Actor *arg2 = 0 ;
57182
57183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57184   arg2 = (Dali::Actor *)jarg2;
57185   if (!arg2) {
57186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57187     return ;
57188   }
57189   {
57190     try {
57191       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
57192     } catch (std::out_of_range& e) {
57193       {
57194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57195       };
57196     } catch (std::exception& e) {
57197       {
57198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57199       };
57200     } catch (...) {
57201       {
57202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57203       };
57204     }
57205   }
57206 }
57207
57208
57209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
57210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57211   Dali::Toolkit::StyleManager arg2 ;
57212   Dali::StyleChange::Type arg3 ;
57213   Dali::Toolkit::StyleManager *argp2 ;
57214
57215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57216   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57217   if (!argp2) {
57218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57219     return ;
57220   }
57221   arg2 = *argp2;
57222   arg3 = (Dali::StyleChange::Type)jarg3;
57223   {
57224     try {
57225       (arg1)->OnStyleChange(arg2,arg3);
57226     } catch (std::out_of_range& e) {
57227       {
57228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57229       };
57230     } catch (std::exception& e) {
57231       {
57232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57233       };
57234     } catch (...) {
57235       {
57236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57237       };
57238     }
57239   }
57240 }
57241
57242
57243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
57244   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57245   Dali::Toolkit::StyleManager arg2 ;
57246   Dali::StyleChange::Type arg3 ;
57247   Dali::Toolkit::StyleManager *argp2 ;
57248
57249   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57250   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
57251   if (!argp2) {
57252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
57253     return ;
57254   }
57255   arg2 = *argp2;
57256   arg3 = (Dali::StyleChange::Type)jarg3;
57257   {
57258     try {
57259       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
57260     } catch (std::out_of_range& e) {
57261       {
57262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57263       };
57264     } catch (std::exception& e) {
57265       {
57266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57267       };
57268     } catch (...) {
57269       {
57270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57271       };
57272     }
57273   }
57274 }
57275
57276
57277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
57278   unsigned int jresult ;
57279   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57280   bool result;
57281
57282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57283   {
57284     try {
57285       result = (bool)(arg1)->OnAccessibilityActivated();
57286     } catch (std::out_of_range& e) {
57287       {
57288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57289       };
57290     } catch (std::exception& e) {
57291       {
57292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57293       };
57294     } catch (...) {
57295       {
57296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57297       };
57298     }
57299   }
57300   jresult = result;
57301   return jresult;
57302 }
57303
57304
57305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
57306   unsigned int jresult ;
57307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57308   bool result;
57309
57310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57311   {
57312     try {
57313       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
57314     } catch (std::out_of_range& e) {
57315       {
57316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57317       };
57318     } catch (std::exception& e) {
57319       {
57320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57321       };
57322     } catch (...) {
57323       {
57324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57325       };
57326     }
57327   }
57328   jresult = result;
57329   return jresult;
57330 }
57331
57332
57333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
57334   unsigned int jresult ;
57335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57336   Dali::PanGesture arg2 ;
57337   Dali::PanGesture *argp2 ;
57338   bool result;
57339
57340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57341   argp2 = (Dali::PanGesture *)jarg2;
57342   if (!argp2) {
57343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57344     return 0;
57345   }
57346   arg2 = *argp2;
57347   {
57348     try {
57349       result = (bool)(arg1)->OnAccessibilityPan(arg2);
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57357       };
57358     } catch (...) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57361       };
57362     }
57363   }
57364   jresult = result;
57365   return jresult;
57366 }
57367
57368
57369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57370   unsigned int jresult ;
57371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57372   Dali::PanGesture arg2 ;
57373   Dali::PanGesture *argp2 ;
57374   bool result;
57375
57376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57377   argp2 = (Dali::PanGesture *)jarg2;
57378   if (!argp2) {
57379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
57380     return 0;
57381   }
57382   arg2 = *argp2;
57383   {
57384     try {
57385       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
57386     } catch (std::out_of_range& e) {
57387       {
57388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57389       };
57390     } catch (std::exception& e) {
57391       {
57392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57393       };
57394     } catch (...) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57397       };
57398     }
57399   }
57400   jresult = result;
57401   return jresult;
57402 }
57403
57404
57405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
57406   unsigned int jresult ;
57407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57408   Dali::TouchEvent *arg2 = 0 ;
57409   bool result;
57410
57411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57412   arg2 = (Dali::TouchEvent *)jarg2;
57413   if (!arg2) {
57414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57415     return 0;
57416   }
57417   {
57418     try {
57419       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57440   unsigned int jresult ;
57441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57442   Dali::TouchEvent *arg2 = 0 ;
57443   bool result;
57444
57445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57446   arg2 = (Dali::TouchEvent *)jarg2;
57447   if (!arg2) {
57448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
57449     return 0;
57450   }
57451   {
57452     try {
57453       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (...) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57465       };
57466     }
57467   }
57468   jresult = result;
57469   return jresult;
57470 }
57471
57472
57473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
57474   unsigned int jresult ;
57475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57476   bool arg2 ;
57477   bool result;
57478
57479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57480   arg2 = jarg2 ? true : false;
57481   {
57482     try {
57483       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
57484     } catch (std::out_of_range& e) {
57485       {
57486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57487       };
57488     } catch (std::exception& e) {
57489       {
57490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57491       };
57492     } catch (...) {
57493       {
57494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57495       };
57496     }
57497   }
57498   jresult = result;
57499   return jresult;
57500 }
57501
57502
57503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
57504   unsigned int jresult ;
57505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57506   bool arg2 ;
57507   bool result;
57508
57509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57510   arg2 = jarg2 ? true : false;
57511   {
57512     try {
57513       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
57514     } catch (std::out_of_range& e) {
57515       {
57516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57517       };
57518     } catch (std::exception& e) {
57519       {
57520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57521       };
57522     } catch (...) {
57523       {
57524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57525       };
57526     }
57527   }
57528   jresult = result;
57529   return jresult;
57530 }
57531
57532
57533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
57534   unsigned int jresult ;
57535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57536   bool result;
57537
57538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57539   {
57540     try {
57541       result = (bool)(arg1)->OnAccessibilityZoom();
57542     } catch (std::out_of_range& e) {
57543       {
57544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57545       };
57546     } catch (std::exception& e) {
57547       {
57548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57549       };
57550     } catch (...) {
57551       {
57552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57553       };
57554     }
57555   }
57556   jresult = result;
57557   return jresult;
57558 }
57559
57560
57561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
57562   unsigned int jresult ;
57563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57564   bool result;
57565
57566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57567   {
57568     try {
57569       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
57570     } catch (std::out_of_range& e) {
57571       {
57572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57573       };
57574     } catch (std::exception& e) {
57575       {
57576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57577       };
57578     } catch (...) {
57579       {
57580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57581       };
57582     }
57583   }
57584   jresult = result;
57585   return jresult;
57586 }
57587
57588
57589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
57590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57591
57592   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57593   {
57594     try {
57595       (arg1)->OnKeyInputFocusGained();
57596     } catch (std::out_of_range& e) {
57597       {
57598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57599       };
57600     } catch (std::exception& e) {
57601       {
57602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57603       };
57604     } catch (...) {
57605       {
57606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57607       };
57608     }
57609   }
57610 }
57611
57612
57613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
57614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57615
57616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57617   {
57618     try {
57619       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57627       };
57628     } catch (...) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57631       };
57632     }
57633   }
57634 }
57635
57636
57637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
57638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57639
57640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57641   {
57642     try {
57643       (arg1)->OnKeyInputFocusLost();
57644     } catch (std::out_of_range& e) {
57645       {
57646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57647       };
57648     } catch (std::exception& e) {
57649       {
57650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57651       };
57652     } catch (...) {
57653       {
57654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57655       };
57656     }
57657   }
57658 }
57659
57660
57661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
57662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57663
57664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57665   {
57666     try {
57667       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
57668     } catch (std::out_of_range& e) {
57669       {
57670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57671       };
57672     } catch (std::exception& e) {
57673       {
57674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57675       };
57676     } catch (...) {
57677       {
57678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57679       };
57680     }
57681   }
57682 }
57683
57684
57685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57686   void * jresult ;
57687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57688   Dali::Actor arg2 ;
57689   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57690   bool arg4 ;
57691   Dali::Actor *argp2 ;
57692   Dali::Actor result;
57693
57694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57695   argp2 = (Dali::Actor *)jarg2;
57696   if (!argp2) {
57697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57698     return 0;
57699   }
57700   arg2 = *argp2;
57701   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57702   arg4 = jarg4 ? true : false;
57703   {
57704     try {
57705       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57713       };
57714     } catch (...) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57717       };
57718     }
57719   }
57720   jresult = new Dali::Actor((const Dali::Actor &)result);
57721   return jresult;
57722 }
57723
57724
57725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
57726   void * jresult ;
57727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57728   Dali::Actor arg2 ;
57729   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
57730   bool arg4 ;
57731   Dali::Actor *argp2 ;
57732   Dali::Actor result;
57733
57734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57735   argp2 = (Dali::Actor *)jarg2;
57736   if (!argp2) {
57737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57738     return 0;
57739   }
57740   arg2 = *argp2;
57741   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
57742   arg4 = jarg4 ? true : false;
57743   {
57744     try {
57745       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (...) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57757       };
57758     }
57759   }
57760   jresult = new Dali::Actor((const Dali::Actor &)result);
57761   return jresult;
57762 }
57763
57764
57765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
57766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57767   Dali::Actor arg2 ;
57768   Dali::Actor *argp2 ;
57769
57770   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57771   argp2 = (Dali::Actor *)jarg2;
57772   if (!argp2) {
57773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57774     return ;
57775   }
57776   arg2 = *argp2;
57777   {
57778     try {
57779       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57787       };
57788     } catch (...) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57791       };
57792     }
57793   }
57794 }
57795
57796
57797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57799   Dali::Actor arg2 ;
57800   Dali::Actor *argp2 ;
57801
57802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57803   argp2 = (Dali::Actor *)jarg2;
57804   if (!argp2) {
57805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57806     return ;
57807   }
57808   arg2 = *argp2;
57809   {
57810     try {
57811       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
57812     } catch (std::out_of_range& e) {
57813       {
57814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57815       };
57816     } catch (std::exception& e) {
57817       {
57818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (...) {
57821       {
57822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57823       };
57824     }
57825   }
57826 }
57827
57828
57829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
57830   unsigned int jresult ;
57831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57832   bool result;
57833
57834   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57835   {
57836     try {
57837       result = (bool)(arg1)->OnKeyboardEnter();
57838     } catch (std::out_of_range& e) {
57839       {
57840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57841       };
57842     } catch (std::exception& e) {
57843       {
57844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (...) {
57847       {
57848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57849       };
57850     }
57851   }
57852   jresult = result;
57853   return jresult;
57854 }
57855
57856
57857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
57858   unsigned int jresult ;
57859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57860   bool result;
57861
57862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57863   {
57864     try {
57865       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
57866     } catch (std::out_of_range& e) {
57867       {
57868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57869       };
57870     } catch (std::exception& e) {
57871       {
57872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57873       };
57874     } catch (...) {
57875       {
57876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57877       };
57878     }
57879   }
57880   jresult = result;
57881   return jresult;
57882 }
57883
57884
57885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
57886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57887   Dali::PinchGesture *arg2 = 0 ;
57888
57889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57890   arg2 = (Dali::PinchGesture *)jarg2;
57891   if (!arg2) {
57892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57893     return ;
57894   }
57895   {
57896     try {
57897       (arg1)->OnPinch((Dali::PinchGesture 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_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57916   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57917   Dali::PinchGesture *arg2 = 0 ;
57918
57919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57920   arg2 = (Dali::PinchGesture *)jarg2;
57921   if (!arg2) {
57922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57923     return ;
57924   }
57925   {
57926     try {
57927       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture 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_OnPan(void * jarg1, void * jarg2) {
57946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57947   Dali::PanGesture *arg2 = 0 ;
57948
57949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57950   arg2 = (Dali::PanGesture *)jarg2;
57951   if (!arg2) {
57952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57953     return ;
57954   }
57955   {
57956     try {
57957       (arg1)->OnPan((Dali::PanGesture 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_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57977   Dali::PanGesture *arg2 = 0 ;
57978
57979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57980   arg2 = (Dali::PanGesture *)jarg2;
57981   if (!arg2) {
57982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57983     return ;
57984   }
57985   {
57986     try {
57987       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
57988     } catch (std::out_of_range& e) {
57989       {
57990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57991       };
57992     } catch (std::exception& e) {
57993       {
57994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57995       };
57996     } catch (...) {
57997       {
57998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57999       };
58000     }
58001   }
58002 }
58003
58004
58005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
58006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58007   Dali::TapGesture *arg2 = 0 ;
58008
58009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58010   arg2 = (Dali::TapGesture *)jarg2;
58011   if (!arg2) {
58012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
58013     return ;
58014   }
58015   {
58016     try {
58017       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
58018     } catch (std::out_of_range& e) {
58019       {
58020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58021       };
58022     } catch (std::exception& e) {
58023       {
58024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58025       };
58026     } catch (...) {
58027       {
58028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58029       };
58030     }
58031   }
58032 }
58033
58034
58035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58037   Dali::TapGesture *arg2 = 0 ;
58038
58039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58040   arg2 = (Dali::TapGesture *)jarg2;
58041   if (!arg2) {
58042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
58043     return ;
58044   }
58045   {
58046     try {
58047       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
58048     } catch (std::out_of_range& e) {
58049       {
58050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (std::exception& e) {
58053       {
58054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58055       };
58056     } catch (...) {
58057       {
58058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58059       };
58060     }
58061   }
58062 }
58063
58064
58065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
58066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58067   Dali::LongPressGesture *arg2 = 0 ;
58068
58069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58070   arg2 = (Dali::LongPressGesture *)jarg2;
58071   if (!arg2) {
58072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
58073     return ;
58074   }
58075   {
58076     try {
58077       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
58078     } catch (std::out_of_range& e) {
58079       {
58080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58081       };
58082     } catch (std::exception& e) {
58083       {
58084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58085       };
58086     } catch (...) {
58087       {
58088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58089       };
58090     }
58091   }
58092 }
58093
58094
58095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58097   Dali::LongPressGesture *arg2 = 0 ;
58098
58099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58100   arg2 = (Dali::LongPressGesture *)jarg2;
58101   if (!arg2) {
58102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
58103     return ;
58104   }
58105   {
58106     try {
58107       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
58108     } catch (std::out_of_range& e) {
58109       {
58110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58111       };
58112     } catch (std::exception& e) {
58113       {
58114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (...) {
58117       {
58118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58119       };
58120     }
58121   }
58122 }
58123
58124
58125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
58126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58127   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58128   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58129
58130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58131   arg2 = (Dali::SlotObserver *)jarg2;
58132   arg3 = (Dali::CallbackBase *)jarg3;
58133   {
58134     try {
58135       (arg1)->SignalConnected(arg2,arg3);
58136     } catch (std::out_of_range& e) {
58137       {
58138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58139       };
58140     } catch (std::exception& e) {
58141       {
58142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58143       };
58144     } catch (...) {
58145       {
58146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58147       };
58148     }
58149   }
58150 }
58151
58152
58153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58155   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58156   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58157
58158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58159   arg2 = (Dali::SlotObserver *)jarg2;
58160   arg3 = (Dali::CallbackBase *)jarg3;
58161   {
58162     try {
58163       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
58164     } catch (std::out_of_range& e) {
58165       {
58166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58167       };
58168     } catch (std::exception& e) {
58169       {
58170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58171       };
58172     } catch (...) {
58173       {
58174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58175       };
58176     }
58177   }
58178 }
58179
58180
58181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
58182   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58183   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58184   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58185
58186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58187   arg2 = (Dali::SlotObserver *)jarg2;
58188   arg3 = (Dali::CallbackBase *)jarg3;
58189   {
58190     try {
58191       (arg1)->SignalDisconnected(arg2,arg3);
58192     } catch (std::out_of_range& e) {
58193       {
58194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58195       };
58196     } catch (std::exception& e) {
58197       {
58198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58199       };
58200     } catch (...) {
58201       {
58202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58203       };
58204     }
58205   }
58206 }
58207
58208
58209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58211   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
58212   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
58213
58214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58215   arg2 = (Dali::SlotObserver *)jarg2;
58216   arg3 = (Dali::CallbackBase *)jarg3;
58217   {
58218     try {
58219       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
58220     } catch (std::out_of_range& e) {
58221       {
58222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58223       };
58224     } catch (std::exception& e) {
58225       {
58226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58227       };
58228     } catch (...) {
58229       {
58230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58231       };
58232     }
58233   }
58234 }
58235
58236
58237 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) {
58238   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
58239   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
58240   if (director) {
58241     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);
58242   }
58243 }
58244
58245
58246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
58247   void * jresult ;
58248   Dali::Toolkit::Control *arg1 = 0 ;
58249   Dali::Toolkit::Internal::Control *result = 0 ;
58250
58251   arg1 = (Dali::Toolkit::Control *)jarg1;
58252   if (!arg1) {
58253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
58254     return 0;
58255   }
58256   {
58257     try {
58258       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
58259     } catch (std::out_of_range& e) {
58260       {
58261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58262       };
58263     } catch (std::exception& e) {
58264       {
58265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58266       };
58267     } catch (...) {
58268       {
58269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58270       };
58271     }
58272   }
58273   jresult = (void *)result;
58274   return jresult;
58275 }
58276
58277
58278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
58279   int jresult ;
58280   int result;
58281
58282   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
58283   jresult = (int)result;
58284   return jresult;
58285 }
58286
58287
58288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
58289   int jresult ;
58290   int result;
58291
58292   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
58293   jresult = (int)result;
58294   return jresult;
58295 }
58296
58297
58298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
58299   int jresult ;
58300   int result;
58301
58302   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
58303   jresult = (int)result;
58304   return jresult;
58305 }
58306
58307
58308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
58309   int jresult ;
58310   int result;
58311
58312   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
58313   jresult = (int)result;
58314   return jresult;
58315 }
58316
58317
58318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
58319   int jresult ;
58320   int result;
58321
58322   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
58323   jresult = (int)result;
58324   return jresult;
58325 }
58326
58327
58328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
58329   void * jresult ;
58330   Dali::Toolkit::Control::Property *result = 0 ;
58331
58332   {
58333     try {
58334       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
58335     } catch (std::out_of_range& e) {
58336       {
58337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58338       };
58339     } catch (std::exception& e) {
58340       {
58341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58346       };
58347     }
58348   }
58349   jresult = (void *)result;
58350   return jresult;
58351 }
58352
58353
58354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
58355   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
58356
58357   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
58358   {
58359     try {
58360       delete arg1;
58361     } catch (std::out_of_range& e) {
58362       {
58363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58364       };
58365     } catch (std::exception& e) {
58366       {
58367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58368       };
58369     } catch (...) {
58370       {
58371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58372       };
58373     }
58374   }
58375 }
58376
58377
58378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
58379   void * jresult ;
58380   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
58381
58382   {
58383     try {
58384       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
58385     } catch (std::out_of_range& e) {
58386       {
58387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58388       };
58389     } catch (std::exception& e) {
58390       {
58391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58392       };
58393     } catch (...) {
58394       {
58395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58396       };
58397     }
58398   }
58399   jresult = (void *)result;
58400   return jresult;
58401 }
58402
58403
58404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
58405   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
58406
58407   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
58408   {
58409     try {
58410       delete arg1;
58411     } catch (std::out_of_range& e) {
58412       {
58413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58414       };
58415     } catch (std::exception& e) {
58416       {
58417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58418       };
58419     } catch (...) {
58420       {
58421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58422       };
58423     }
58424   }
58425 }
58426
58427
58428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
58429   void * jresult ;
58430   Dali::Toolkit::Control result;
58431
58432   {
58433     try {
58434       result = Dali::Toolkit::Control::New();
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_new_View__SWIG_0() {
58455   void * jresult ;
58456   Dali::Toolkit::Control *result = 0 ;
58457
58458   {
58459     try {
58460       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
58461     } catch (std::out_of_range& e) {
58462       {
58463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58464       };
58465     } catch (std::exception& e) {
58466       {
58467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58468       };
58469     } catch (...) {
58470       {
58471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58472       };
58473     }
58474   }
58475   jresult = (void *)result;
58476   return jresult;
58477 }
58478
58479
58480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
58481   void * jresult ;
58482   Dali::Toolkit::Control *arg1 = 0 ;
58483   Dali::Toolkit::Control *result = 0 ;
58484
58485   arg1 = (Dali::Toolkit::Control *)jarg1;
58486   if (!arg1) {
58487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58488     return 0;
58489   }
58490   {
58491     try {
58492       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
58493     } catch (std::out_of_range& e) {
58494       {
58495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58496       };
58497     } catch (std::exception& e) {
58498       {
58499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58500       };
58501     } catch (...) {
58502       {
58503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58504       };
58505     }
58506   }
58507   jresult = (void *)result;
58508   return jresult;
58509 }
58510
58511
58512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
58513   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58514
58515   arg1 = (Dali::Toolkit::Control *)jarg1;
58516   {
58517     try {
58518       delete arg1;
58519     } catch (std::out_of_range& e) {
58520       {
58521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58522       };
58523     } catch (std::exception& e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58526       };
58527     } catch (...) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58530       };
58531     }
58532   }
58533 }
58534
58535
58536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
58537   void * jresult ;
58538   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58539   Dali::Toolkit::Control *arg2 = 0 ;
58540   Dali::Toolkit::Control *result = 0 ;
58541
58542   arg1 = (Dali::Toolkit::Control *)jarg1;
58543   arg2 = (Dali::Toolkit::Control *)jarg2;
58544   if (!arg2) {
58545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
58546     return 0;
58547   }
58548   {
58549     try {
58550       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
58551     } catch (std::out_of_range& e) {
58552       {
58553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58554       };
58555     } catch (std::exception& e) {
58556       {
58557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58558       };
58559     } catch (...) {
58560       {
58561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58562       };
58563     }
58564   }
58565   jresult = (void *)result;
58566   return jresult;
58567 }
58568
58569
58570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
58571   void * jresult ;
58572   Dali::BaseHandle arg1 ;
58573   Dali::BaseHandle *argp1 ;
58574   Dali::Toolkit::Control result;
58575
58576   argp1 = (Dali::BaseHandle *)jarg1;
58577   if (!argp1) {
58578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58579     return 0;
58580   }
58581   arg1 = *argp1;
58582   {
58583     try {
58584       result = Dali::Toolkit::Control::DownCast(arg1);
58585     } catch (std::out_of_range& e) {
58586       {
58587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (std::exception& e) {
58590       {
58591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (...) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58596       };
58597     }
58598   }
58599   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58600   return jresult;
58601 }
58602
58603
58604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
58605   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58606
58607   arg1 = (Dali::Toolkit::Control *)jarg1;
58608   {
58609     try {
58610       (arg1)->SetKeyInputFocus();
58611     } catch (std::out_of_range& e) {
58612       {
58613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58614       };
58615     } catch (std::exception& e) {
58616       {
58617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58618       };
58619     } catch (...) {
58620       {
58621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58622       };
58623     }
58624   }
58625 }
58626
58627
58628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
58629   unsigned int jresult ;
58630   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58631   bool result;
58632
58633   arg1 = (Dali::Toolkit::Control *)jarg1;
58634   {
58635     try {
58636       result = (bool)(arg1)->HasKeyInputFocus();
58637     } catch (std::out_of_range& e) {
58638       {
58639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58640       };
58641     } catch (std::exception& e) {
58642       {
58643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58644       };
58645     } catch (...) {
58646       {
58647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58648       };
58649     }
58650   }
58651   jresult = result;
58652   return jresult;
58653 }
58654
58655
58656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
58657   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58658
58659   arg1 = (Dali::Toolkit::Control *)jarg1;
58660   {
58661     try {
58662       (arg1)->ClearKeyInputFocus();
58663     } catch (std::out_of_range& e) {
58664       {
58665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58666       };
58667     } catch (std::exception& e) {
58668       {
58669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58674       };
58675     }
58676   }
58677 }
58678
58679
58680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
58681   void * jresult ;
58682   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58683   Dali::PinchGestureDetector result;
58684
58685   arg1 = (Dali::Toolkit::Control *)jarg1;
58686   {
58687     try {
58688       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
58689     } catch (std::out_of_range& e) {
58690       {
58691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58692       };
58693     } catch (std::exception& e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58696       };
58697     } catch (...) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58700       };
58701     }
58702   }
58703   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58704   return jresult;
58705 }
58706
58707
58708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
58709   void * jresult ;
58710   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58711   Dali::PanGestureDetector result;
58712
58713   arg1 = (Dali::Toolkit::Control *)jarg1;
58714   {
58715     try {
58716       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58732   return jresult;
58733 }
58734
58735
58736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
58737   void * jresult ;
58738   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58739   Dali::TapGestureDetector result;
58740
58741   arg1 = (Dali::Toolkit::Control *)jarg1;
58742   {
58743     try {
58744       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
58745     } catch (std::out_of_range& e) {
58746       {
58747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58748       };
58749     } catch (std::exception& e) {
58750       {
58751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58752       };
58753     } catch (...) {
58754       {
58755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58756       };
58757     }
58758   }
58759   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58760   return jresult;
58761 }
58762
58763
58764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
58765   void * jresult ;
58766   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58767   Dali::LongPressGestureDetector result;
58768
58769   arg1 = (Dali::Toolkit::Control *)jarg1;
58770   {
58771     try {
58772       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
58773     } catch (std::out_of_range& e) {
58774       {
58775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (std::exception& e) {
58778       {
58779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58780       };
58781     } catch (...) {
58782       {
58783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58784       };
58785     }
58786   }
58787   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58788   return jresult;
58789 }
58790
58791
58792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
58793   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58794   std::string *arg2 = 0 ;
58795
58796   arg1 = (Dali::Toolkit::Control *)jarg1;
58797   if (!jarg2) {
58798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58799     return ;
58800   }
58801   std::string arg2_str(jarg2);
58802   arg2 = &arg2_str;
58803   {
58804     try {
58805       (arg1)->SetStyleName((std::string const &)*arg2);
58806     } catch (std::out_of_range& e) {
58807       {
58808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58809       };
58810     } catch (std::exception& e) {
58811       {
58812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58813       };
58814     } catch (...) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58817       };
58818     }
58819   }
58820
58821   //argout typemap for const std::string&
58822
58823 }
58824
58825
58826 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
58827   char * jresult ;
58828   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58829   std::string *result = 0 ;
58830
58831   arg1 = (Dali::Toolkit::Control *)jarg1;
58832   {
58833     try {
58834       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
58835     } catch (std::out_of_range& e) {
58836       {
58837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58838       };
58839     } catch (std::exception& e) {
58840       {
58841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58842       };
58843     } catch (...) {
58844       {
58845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58846       };
58847     }
58848   }
58849   jresult = SWIG_csharp_string_callback(result->c_str());
58850   return jresult;
58851 }
58852
58853
58854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
58855   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58856   Dali::Vector4 *arg2 = 0 ;
58857
58858   arg1 = (Dali::Toolkit::Control *)jarg1;
58859   arg2 = (Dali::Vector4 *)jarg2;
58860   if (!arg2) {
58861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58862     return ;
58863   }
58864   {
58865     try {
58866       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58867     } catch (std::out_of_range& e) {
58868       {
58869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58870       };
58871     } catch (std::exception& e) {
58872       {
58873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58874       };
58875     } catch (...) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58878       };
58879     }
58880   }
58881 }
58882
58883
58884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
58885   void * jresult ;
58886   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58887   Dali::Vector4 result;
58888
58889   arg1 = (Dali::Toolkit::Control *)jarg1;
58890   {
58891     try {
58892       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
58893     } catch (std::out_of_range& e) {
58894       {
58895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58896       };
58897     } catch (std::exception& e) {
58898       {
58899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (...) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58904       };
58905     }
58906   }
58907   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58908   return jresult;
58909 }
58910
58911
58912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
58913   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58914   Dali::Image arg2 ;
58915   Dali::Image *argp2 ;
58916
58917   arg1 = (Dali::Toolkit::Control *)jarg1;
58918   argp2 = (Dali::Image *)jarg2;
58919   if (!argp2) {
58920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58921     return ;
58922   }
58923   arg2 = *argp2;
58924   {
58925     try {
58926       (arg1)->SetBackgroundImage(arg2);
58927     } catch (std::out_of_range& e) {
58928       {
58929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58930       };
58931     } catch (std::exception& e) {
58932       {
58933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58934       };
58935     } catch (...) {
58936       {
58937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58938       };
58939     }
58940   }
58941 }
58942
58943
58944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
58945   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58946
58947   arg1 = (Dali::Toolkit::Control *)jarg1;
58948   {
58949     try {
58950       (arg1)->ClearBackground();
58951     } catch (std::out_of_range& e) {
58952       {
58953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58954       };
58955     } catch (std::exception& e) {
58956       {
58957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58962       };
58963     }
58964   }
58965 }
58966
58967
58968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
58969   void * jresult ;
58970   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58971   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
58972
58973   arg1 = (Dali::Toolkit::Control *)jarg1;
58974   {
58975     try {
58976       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (...) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58988       };
58989     }
58990   }
58991   jresult = (void *)result;
58992   return jresult;
58993 }
58994
58995
58996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
58997   void * jresult ;
58998   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
58999   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59000
59001   arg1 = (Dali::Toolkit::Control *)jarg1;
59002   {
59003     try {
59004       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59005     } catch (std::out_of_range& e) {
59006       {
59007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (std::exception& e) {
59010       {
59011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (...) {
59014       {
59015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59016       };
59017     }
59018   }
59019   jresult = (void *)result;
59020   return jresult;
59021 }
59022
59023
59024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
59025   void * jresult ;
59026   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59027   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59028
59029   arg1 = (Dali::Toolkit::Control *)jarg1;
59030   {
59031     try {
59032       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59033     } catch (std::out_of_range& e) {
59034       {
59035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59036       };
59037     } catch (std::exception& e) {
59038       {
59039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59040       };
59041     } catch (...) {
59042       {
59043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59044       };
59045     }
59046   }
59047   jresult = (void *)result;
59048   return jresult;
59049 }
59050
59051
59052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
59053   void * jresult ;
59054   Dali::Toolkit::Internal::Control *arg1 = 0 ;
59055   Dali::Toolkit::Control *result = 0 ;
59056
59057   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59058   if (!arg1) {
59059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
59060     return 0;
59061   }
59062   {
59063     try {
59064       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
59065     } catch (std::out_of_range& e) {
59066       {
59067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59068       };
59069     } catch (std::exception& e) {
59070       {
59071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (...) {
59074       {
59075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59076       };
59077     }
59078   }
59079   jresult = (void *)result;
59080   return jresult;
59081 }
59082
59083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
59084 {
59085   int jresult;
59086   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59087   arg1 = (Dali::Toolkit::Control *)jarg1;
59088
59089   if (!arg1) {
59090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59091     return 0;
59092   }
59093
59094   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
59095
59096   Dali::Property::Index arg2 = 0 ;
59097   arg2 = (Dali::Property::Index)jarg2;
59098
59099   Toolkit::Visual::ResourceStatus result;
59100   {
59101     try {
59102       result = DevelControl::GetVisualResourceStatus(controlImpl, arg2);
59103     } catch (std::out_of_range& e) {
59104       {
59105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59106       };
59107     } catch (std::exception& e) {
59108       {
59109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59110       };
59111     } catch (...) {
59112       {
59113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59114       };
59115     }
59116   }
59117   jresult = (int)(result);
59118   return jresult;
59119 }
59120
59121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
59122 {
59123   void * jresult;
59124   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
59125   arg1 = (Dali::Toolkit::Control *)jarg1;
59126
59127   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
59128
59129   Dali::Toolkit::TransitionData *arg2 = 0 ;
59130   Dali::Animation result;
59131
59132   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59133   if (!arg2) {
59134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59135     return 0;
59136   }
59137   {
59138     try {
59139       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
59140     } catch (std::out_of_range& e) {
59141       {
59142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59143       };
59144     } catch (std::exception& e) {
59145       {
59146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59147       };
59148     } catch (...) {
59149       {
59150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59151       };
59152     }
59153   }
59154   jresult = new Dali::Animation((const Dali::Animation &)result);
59155   return jresult;
59156 }
59157
59158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
59159   void * jresult ;
59160   Dali::Toolkit::Control *arg1 = 0 ;
59161   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
59162
59163   arg1 = (Dali::Toolkit::Control *)jarg1;
59164   if (!arg1) {
59165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
59166     return 0;
59167   }
59168   {
59169     try {
59170       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
59171     } catch (std::out_of_range& e) {
59172       {
59173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59174       };
59175     } catch (std::exception& e) {
59176       {
59177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59178       };
59179     } catch (...) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59182       };
59183     }
59184   }
59185   jresult = (void *)result;
59186   return jresult;
59187 }
59188
59189
59190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
59191   unsigned int jresult ;
59192   Dali::Toolkit::Control *arg1 = 0 ;
59193   bool result;
59194
59195   arg1 = (Dali::Toolkit::Control *)jarg1;
59196   if (!arg1) {
59197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
59198     return 0;
59199   }
59200   {
59201     try {
59202       result = (bool)arg1->IsResourceReady();
59203     } catch (std::out_of_range& e) {
59204       {
59205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59206       };
59207     } catch (std::exception& e) {
59208       {
59209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59214       };
59215     }
59216   }
59217   jresult = result;
59218   return jresult;
59219 }
59220
59221
59222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
59223   void * jresult ;
59224   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
59225
59226   {
59227     try {
59228       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59240       };
59241     }
59242   }
59243   jresult = (void *)result;
59244   return jresult;
59245 }
59246
59247
59248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
59249   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59250
59251   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59252   {
59253     try {
59254       delete arg1;
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59262       };
59263     } catch (...) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59266       };
59267     }
59268   }
59269 }
59270
59271
59272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
59273   void * jresult ;
59274   Dali::Toolkit::KeyInputFocusManager result;
59275
59276   {
59277     try {
59278       result = Dali::Toolkit::KeyInputFocusManager::Get();
59279     } catch (std::out_of_range& e) {
59280       {
59281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59282       };
59283     } catch (std::exception& e) {
59284       {
59285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (...) {
59288       {
59289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59290       };
59291     }
59292   }
59293   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
59294   return jresult;
59295 }
59296
59297
59298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
59299   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59300   Dali::Toolkit::Control arg2 ;
59301   Dali::Toolkit::Control *argp2 ;
59302
59303   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59304   argp2 = (Dali::Toolkit::Control *)jarg2;
59305   if (!argp2) {
59306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59307     return ;
59308   }
59309   arg2 = *argp2;
59310   {
59311     try {
59312       (arg1)->SetFocus(arg2);
59313     } catch (std::out_of_range& e) {
59314       {
59315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59316       };
59317     } catch (std::exception& e) {
59318       {
59319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59320       };
59321     } catch (...) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59324       };
59325     }
59326   }
59327 }
59328
59329
59330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
59331   void * jresult ;
59332   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59333   Dali::Toolkit::Control result;
59334
59335   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59336   {
59337     try {
59338       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
59339     } catch (std::out_of_range& e) {
59340       {
59341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59342       };
59343     } catch (std::exception& e) {
59344       {
59345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59346       };
59347     } catch (...) {
59348       {
59349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59350       };
59351     }
59352   }
59353   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59354   return jresult;
59355 }
59356
59357
59358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
59359   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59360   Dali::Toolkit::Control arg2 ;
59361   Dali::Toolkit::Control *argp2 ;
59362
59363   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59364   argp2 = (Dali::Toolkit::Control *)jarg2;
59365   if (!argp2) {
59366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
59367     return ;
59368   }
59369   arg2 = *argp2;
59370   {
59371     try {
59372       (arg1)->RemoveFocus(arg2);
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (...) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59384       };
59385     }
59386   }
59387 }
59388
59389
59390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
59391   void * jresult ;
59392   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
59393   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
59394
59395   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
59396   {
59397     try {
59398       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
59399     } catch (std::out_of_range& e) {
59400       {
59401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59402       };
59403     } catch (std::exception& e) {
59404       {
59405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59406       };
59407     } catch (...) {
59408       {
59409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59410       };
59411     }
59412   }
59413   jresult = (void *)result;
59414   return jresult;
59415 }
59416
59417
59418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
59419   void * jresult ;
59420   Dali::Toolkit::Alignment::Padding *result = 0 ;
59421
59422   {
59423     try {
59424       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
59425     } catch (std::out_of_range& e) {
59426       {
59427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59428       };
59429     } catch (std::exception& e) {
59430       {
59431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59432       };
59433     } catch (...) {
59434       {
59435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59436       };
59437     }
59438   }
59439   jresult = (void *)result;
59440   return jresult;
59441 }
59442
59443
59444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
59445   void * jresult ;
59446   float arg1 ;
59447   float arg2 ;
59448   float arg3 ;
59449   float arg4 ;
59450   Dali::Toolkit::Alignment::Padding *result = 0 ;
59451
59452   arg1 = (float)jarg1;
59453   arg2 = (float)jarg2;
59454   arg3 = (float)jarg3;
59455   arg4 = (float)jarg4;
59456   {
59457     try {
59458       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
59459     } catch (std::out_of_range& e) {
59460       {
59461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59462       };
59463     } catch (std::exception& e) {
59464       {
59465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59466       };
59467     } catch (...) {
59468       {
59469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59470       };
59471     }
59472   }
59473   jresult = (void *)result;
59474   return jresult;
59475 }
59476
59477
59478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
59479   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59480   float arg2 ;
59481
59482   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59483   arg2 = (float)jarg2;
59484   if (arg1) (arg1)->left = arg2;
59485 }
59486
59487
59488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
59489   float jresult ;
59490   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59491   float result;
59492
59493   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59494   result = (float) ((arg1)->left);
59495   jresult = result;
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
59501   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59502   float arg2 ;
59503
59504   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59505   arg2 = (float)jarg2;
59506   if (arg1) (arg1)->right = arg2;
59507 }
59508
59509
59510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
59511   float jresult ;
59512   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59513   float result;
59514
59515   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59516   result = (float) ((arg1)->right);
59517   jresult = result;
59518   return jresult;
59519 }
59520
59521
59522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
59523   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59524   float arg2 ;
59525
59526   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59527   arg2 = (float)jarg2;
59528   if (arg1) (arg1)->top = arg2;
59529 }
59530
59531
59532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
59533   float jresult ;
59534   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59535   float result;
59536
59537   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59538   result = (float) ((arg1)->top);
59539   jresult = result;
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
59545   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59546   float arg2 ;
59547
59548   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59549   arg2 = (float)jarg2;
59550   if (arg1) (arg1)->bottom = arg2;
59551 }
59552
59553
59554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
59555   float jresult ;
59556   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59557   float result;
59558
59559   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59560   result = (float) ((arg1)->bottom);
59561   jresult = result;
59562   return jresult;
59563 }
59564
59565
59566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
59567   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
59568
59569   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
59570   {
59571     try {
59572       delete arg1;
59573     } catch (std::out_of_range& e) {
59574       {
59575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59576       };
59577     } catch (std::exception& e) {
59578       {
59579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59580       };
59581     } catch (...) {
59582       {
59583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59584       };
59585     }
59586   }
59587 }
59588
59589
59590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
59591   void * jresult ;
59592   Dali::Toolkit::Alignment *result = 0 ;
59593
59594   {
59595     try {
59596       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
59597     } catch (std::out_of_range& e) {
59598       {
59599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59600       };
59601     } catch (std::exception& e) {
59602       {
59603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59604       };
59605     } catch (...) {
59606       {
59607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59608       };
59609     }
59610   }
59611   jresult = (void *)result;
59612   return jresult;
59613 }
59614
59615
59616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
59617   void * jresult ;
59618   Dali::Toolkit::Alignment::Type arg1 ;
59619   Dali::Toolkit::Alignment::Type arg2 ;
59620   Dali::Toolkit::Alignment result;
59621
59622   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59623   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59624   {
59625     try {
59626       result = Dali::Toolkit::Alignment::New(arg1,arg2);
59627     } catch (std::out_of_range& e) {
59628       {
59629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59630       };
59631     } catch (std::exception& e) {
59632       {
59633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59634       };
59635     } catch (...) {
59636       {
59637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59638       };
59639     }
59640   }
59641   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59642   return jresult;
59643 }
59644
59645
59646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
59647   void * jresult ;
59648   Dali::Toolkit::Alignment::Type arg1 ;
59649   Dali::Toolkit::Alignment result;
59650
59651   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
59652   {
59653     try {
59654       result = Dali::Toolkit::Alignment::New(arg1);
59655     } catch (std::out_of_range& e) {
59656       {
59657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59658       };
59659     } catch (std::exception& e) {
59660       {
59661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (...) {
59664       {
59665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59666       };
59667     }
59668   }
59669   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59670   return jresult;
59671 }
59672
59673
59674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
59675   void * jresult ;
59676   Dali::Toolkit::Alignment result;
59677
59678   {
59679     try {
59680       result = Dali::Toolkit::Alignment::New();
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (...) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59692       };
59693     }
59694   }
59695   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59696   return jresult;
59697 }
59698
59699
59700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
59701   void * jresult ;
59702   Dali::Toolkit::Alignment *arg1 = 0 ;
59703   Dali::Toolkit::Alignment *result = 0 ;
59704
59705   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59706   if (!arg1) {
59707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59708     return 0;
59709   }
59710   {
59711     try {
59712       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
59713     } catch (std::out_of_range& e) {
59714       {
59715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (std::exception& e) {
59718       {
59719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (...) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59724       };
59725     }
59726   }
59727   jresult = (void *)result;
59728   return jresult;
59729 }
59730
59731
59732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
59733   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59734
59735   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59736   {
59737     try {
59738       delete arg1;
59739     } catch (std::out_of_range& e) {
59740       {
59741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59742       };
59743     } catch (std::exception& e) {
59744       {
59745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59746       };
59747     } catch (...) {
59748       {
59749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59750       };
59751     }
59752   }
59753 }
59754
59755
59756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
59757   void * jresult ;
59758   Dali::BaseHandle arg1 ;
59759   Dali::BaseHandle *argp1 ;
59760   Dali::Toolkit::Alignment result;
59761
59762   argp1 = (Dali::BaseHandle *)jarg1;
59763   if (!argp1) {
59764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59765     return 0;
59766   }
59767   arg1 = *argp1;
59768   {
59769     try {
59770       result = Dali::Toolkit::Alignment::DownCast(arg1);
59771     } catch (std::out_of_range& e) {
59772       {
59773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59774       };
59775     } catch (std::exception& e) {
59776       {
59777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59778       };
59779     } catch (...) {
59780       {
59781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59782       };
59783     }
59784   }
59785   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
59786   return jresult;
59787 }
59788
59789
59790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
59791   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59792   Dali::Toolkit::Alignment::Type arg2 ;
59793
59794   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59795   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
59796   {
59797     try {
59798       (arg1)->SetAlignmentType(arg2);
59799     } catch (std::out_of_range& e) {
59800       {
59801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59802       };
59803     } catch (std::exception& e) {
59804       {
59805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59806       };
59807     } catch (...) {
59808       {
59809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59810       };
59811     }
59812   }
59813 }
59814
59815
59816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
59817   int jresult ;
59818   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59819   Dali::Toolkit::Alignment::Type result;
59820
59821   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59822   {
59823     try {
59824       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
59825     } catch (std::out_of_range& e) {
59826       {
59827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59828       };
59829     } catch (std::exception& e) {
59830       {
59831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59832       };
59833     } catch (...) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59836       };
59837     }
59838   }
59839   jresult = (int)result;
59840   return jresult;
59841 }
59842
59843
59844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
59845   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59846   Dali::Toolkit::Alignment::Scaling arg2 ;
59847
59848   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59849   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
59850   {
59851     try {
59852       (arg1)->SetScaling(arg2);
59853     } catch (std::out_of_range& e) {
59854       {
59855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59856       };
59857     } catch (std::exception& e) {
59858       {
59859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59860       };
59861     } catch (...) {
59862       {
59863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59864       };
59865     }
59866   }
59867 }
59868
59869
59870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
59871   int jresult ;
59872   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59873   Dali::Toolkit::Alignment::Scaling result;
59874
59875   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59876   {
59877     try {
59878       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
59879     } catch (std::out_of_range& e) {
59880       {
59881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59882       };
59883     } catch (std::exception& e) {
59884       {
59885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59886       };
59887     } catch (...) {
59888       {
59889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59890       };
59891     }
59892   }
59893   jresult = (int)result;
59894   return jresult;
59895 }
59896
59897
59898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
59899   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59900   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
59901
59902   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59903   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
59904   if (!arg2) {
59905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
59906     return ;
59907   }
59908   {
59909     try {
59910       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
59911     } catch (std::out_of_range& e) {
59912       {
59913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59914       };
59915     } catch (std::exception& e) {
59916       {
59917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59918       };
59919     } catch (...) {
59920       {
59921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59922       };
59923     }
59924   }
59925 }
59926
59927
59928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
59929   void * jresult ;
59930   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59931   Dali::Toolkit::Alignment::Padding *result = 0 ;
59932
59933   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59934   {
59935     try {
59936       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
59937     } catch (std::out_of_range& e) {
59938       {
59939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59940       };
59941     } catch (std::exception& e) {
59942       {
59943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59944       };
59945     } catch (...) {
59946       {
59947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59948       };
59949     }
59950   }
59951   jresult = (void *)result;
59952   return jresult;
59953 }
59954
59955
59956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
59957   void * jresult ;
59958   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
59959   Dali::Toolkit::Alignment *arg2 = 0 ;
59960   Dali::Toolkit::Alignment *result = 0 ;
59961
59962   arg1 = (Dali::Toolkit::Alignment *)jarg1;
59963   arg2 = (Dali::Toolkit::Alignment *)jarg2;
59964   if (!arg2) {
59965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
59966     return 0;
59967   }
59968   {
59969     try {
59970       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
59971     } catch (std::out_of_range& e) {
59972       {
59973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59974       };
59975     } catch (std::exception& e) {
59976       {
59977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59978       };
59979     } catch (...) {
59980       {
59981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59982       };
59983     }
59984   }
59985   jresult = (void *)result;
59986   return jresult;
59987 }
59988
59989
59990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
59991   int jresult ;
59992   int result;
59993
59994   result = (int)Dali::Toolkit::Button::Property::DISABLED;
59995   jresult = (int)result;
59996   return jresult;
59997 }
59998
59999
60000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
60001   int jresult ;
60002   int result;
60003
60004   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
60005   jresult = (int)result;
60006   return jresult;
60007 }
60008
60009
60010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
60011   int jresult ;
60012   int result;
60013
60014   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
60015   jresult = (int)result;
60016   return jresult;
60017 }
60018
60019
60020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
60021   int jresult ;
60022   int result;
60023
60024   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
60025   jresult = (int)result;
60026   return jresult;
60027 }
60028
60029
60030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
60031   int jresult ;
60032   int result;
60033
60034   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
60035   jresult = (int)result;
60036   return jresult;
60037 }
60038
60039
60040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
60041   int jresult ;
60042   int result;
60043
60044   result = (int)Dali::Toolkit::Button::Property::SELECTED;
60045   jresult = (int)result;
60046   return jresult;
60047 }
60048
60049
60050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
60051   int jresult ;
60052   int result;
60053
60054   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
60055   jresult = (int)result;
60056   return jresult;
60057 }
60058
60059
60060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
60061   int jresult ;
60062   int result;
60063
60064   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
60065   jresult = (int)result;
60066   return jresult;
60067 }
60068
60069
60070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
60071   int jresult ;
60072   int result;
60073
60074   result = (int)Dali::Toolkit::Button::Property::LABEL;
60075   jresult = (int)result;
60076   return jresult;
60077 }
60078
60079
60080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
60081   int jresult ;
60082   int result;
60083
60084   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
60085   jresult = (int)result;
60086   return jresult;
60087 }
60088
60089
60090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
60091   void * jresult ;
60092   Dali::Toolkit::Button::Property *result = 0 ;
60093
60094   {
60095     try {
60096       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
60097     } catch (std::out_of_range& e) {
60098       {
60099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (std::exception& e) {
60102       {
60103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111   jresult = (void *)result;
60112   return jresult;
60113 }
60114
60115
60116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
60117   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
60118
60119   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
60120   {
60121     try {
60122       delete arg1;
60123     } catch (std::out_of_range& e) {
60124       {
60125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60126       };
60127     } catch (std::exception& e) {
60128       {
60129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60130       };
60131     } catch (...) {
60132       {
60133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60134       };
60135     }
60136   }
60137 }
60138
60139
60140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
60141   void * jresult ;
60142   Dali::Toolkit::Button *result = 0 ;
60143
60144   {
60145     try {
60146       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
60147     } catch (std::out_of_range& e) {
60148       {
60149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60150       };
60151     } catch (std::exception& e) {
60152       {
60153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60154       };
60155     } catch (...) {
60156       {
60157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60158       };
60159     }
60160   }
60161   jresult = (void *)result;
60162   return jresult;
60163 }
60164
60165
60166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
60167   void * jresult ;
60168   Dali::Toolkit::Button *arg1 = 0 ;
60169   Dali::Toolkit::Button *result = 0 ;
60170
60171   arg1 = (Dali::Toolkit::Button *)jarg1;
60172   if (!arg1) {
60173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60174     return 0;
60175   }
60176   {
60177     try {
60178       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193   jresult = (void *)result;
60194   return jresult;
60195 }
60196
60197
60198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
60199   void * jresult ;
60200   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60201   Dali::Toolkit::Button *arg2 = 0 ;
60202   Dali::Toolkit::Button *result = 0 ;
60203
60204   arg1 = (Dali::Toolkit::Button *)jarg1;
60205   arg2 = (Dali::Toolkit::Button *)jarg2;
60206   if (!arg2) {
60207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
60208     return 0;
60209   }
60210   {
60211     try {
60212       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
60213     } catch (std::out_of_range& e) {
60214       {
60215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60216       };
60217     } catch (std::exception& e) {
60218       {
60219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60220       };
60221     } catch (...) {
60222       {
60223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60224       };
60225     }
60226   }
60227   jresult = (void *)result;
60228   return jresult;
60229 }
60230
60231
60232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
60233   void * jresult ;
60234   Dali::BaseHandle arg1 ;
60235   Dali::BaseHandle *argp1 ;
60236   Dali::Toolkit::Button result;
60237
60238   argp1 = (Dali::BaseHandle *)jarg1;
60239   if (!argp1) {
60240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60241     return 0;
60242   }
60243   arg1 = *argp1;
60244   {
60245     try {
60246       result = Dali::Toolkit::Button::DownCast(arg1);
60247     } catch (std::out_of_range& e) {
60248       {
60249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (std::exception& e) {
60252       {
60253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (...) {
60256       {
60257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60258       };
60259     }
60260   }
60261   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
60262   return jresult;
60263 }
60264
60265
60266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
60267   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60268
60269   arg1 = (Dali::Toolkit::Button *)jarg1;
60270   {
60271     try {
60272       delete arg1;
60273     } catch (std::out_of_range& e) {
60274       {
60275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60276       };
60277     } catch (std::exception& e) {
60278       {
60279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60284       };
60285     }
60286   }
60287 }
60288
60289
60290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
60291   unsigned int jresult ;
60292   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60293   bool result;
60294
60295   arg1 = (Dali::Toolkit::Button *)jarg1;
60296   {
60297     try {
60298       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
60299     } catch (std::out_of_range& e) {
60300       {
60301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60302       };
60303     } catch (std::exception& e) {
60304       {
60305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (...) {
60308       {
60309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60310       };
60311     }
60312   }
60313   jresult = result;
60314   return jresult;
60315 }
60316
60317
60318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
60319   unsigned int jresult ;
60320   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60321   bool result;
60322
60323   arg1 = (Dali::Toolkit::Button *)jarg1;
60324   {
60325     try {
60326       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
60327     } catch (std::out_of_range& e) {
60328       {
60329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (std::exception& e) {
60332       {
60333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (...) {
60336       {
60337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60338       };
60339     }
60340   }
60341   jresult = result;
60342   return jresult;
60343 }
60344
60345
60346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
60347   float jresult ;
60348   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60349   float result;
60350
60351   arg1 = (Dali::Toolkit::Button *)jarg1;
60352   {
60353     try {
60354       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
60355     } catch (std::out_of_range& e) {
60356       {
60357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (std::exception& e) {
60360       {
60361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (...) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60366       };
60367     }
60368   }
60369   jresult = result;
60370   return jresult;
60371 }
60372
60373
60374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
60375   float jresult ;
60376   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60377   float result;
60378
60379   arg1 = (Dali::Toolkit::Button *)jarg1;
60380   {
60381     try {
60382       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
60383     } catch (std::out_of_range& e) {
60384       {
60385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60386       };
60387     } catch (std::exception& e) {
60388       {
60389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60390       };
60391     } catch (...) {
60392       {
60393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60394       };
60395     }
60396   }
60397   jresult = result;
60398   return jresult;
60399 }
60400
60401
60402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
60403   unsigned int jresult ;
60404   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60405   bool result;
60406
60407   arg1 = (Dali::Toolkit::Button *)jarg1;
60408   {
60409     try {
60410       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
60411     } catch (std::out_of_range& e) {
60412       {
60413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (std::exception& e) {
60416       {
60417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60418       };
60419     } catch (...) {
60420       {
60421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60422       };
60423     }
60424   }
60425   jresult = result;
60426   return jresult;
60427 }
60428
60429
60430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
60431   unsigned int jresult ;
60432   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60433   bool result;
60434
60435   arg1 = (Dali::Toolkit::Button *)jarg1;
60436   {
60437     try {
60438       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
60439     } catch (std::out_of_range& e) {
60440       {
60441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60442       };
60443     } catch (std::exception& e) {
60444       {
60445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60446       };
60447     } catch (...) {
60448       {
60449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60450       };
60451     }
60452   }
60453   jresult = result;
60454   return jresult;
60455 }
60456
60457
60458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
60459   float jresult ;
60460   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60461   float result;
60462
60463   arg1 = (Dali::Toolkit::Button *)jarg1;
60464   {
60465     try {
60466       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
60467     } catch (std::out_of_range& e) {
60468       {
60469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60470       };
60471     } catch (std::exception& e) {
60472       {
60473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60474       };
60475     } catch (...) {
60476       {
60477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60478       };
60479     }
60480   }
60481   jresult = result;
60482   return jresult;
60483 }
60484
60485
60486 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
60487   char * jresult ;
60488   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60489   std::string result;
60490
60491   arg1 = (Dali::Toolkit::Button *)jarg1;
60492   {
60493     try {
60494       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
60495     } catch (std::out_of_range& e) {
60496       {
60497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60498       };
60499     } catch (std::exception& e) {
60500       {
60501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (...) {
60504       {
60505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60506       };
60507     }
60508   }
60509   jresult = SWIG_csharp_string_callback((&result)->c_str());
60510   return jresult;
60511 }
60512
60513
60514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
60515   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60516   Dali::Actor arg2 ;
60517   Dali::Actor *argp2 ;
60518
60519   arg1 = (Dali::Toolkit::Button *)jarg1;
60520   argp2 = (Dali::Actor *)jarg2;
60521   if (!argp2) {
60522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60523     return ;
60524   }
60525   arg2 = *argp2;
60526   {
60527     try {
60528       (arg1)->SetLabel(arg2);
60529     } catch (std::out_of_range& e) {
60530       {
60531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60532       };
60533     } catch (std::exception& e) {
60534       {
60535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60536       };
60537     } catch (...) {
60538       {
60539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60540       };
60541     }
60542   }
60543 }
60544
60545
60546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
60547   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60548   Dali::Image arg2 ;
60549   Dali::Image *argp2 ;
60550
60551   arg1 = (Dali::Toolkit::Button *)jarg1;
60552   argp2 = (Dali::Image *)jarg2;
60553   if (!argp2) {
60554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60555     return ;
60556   }
60557   arg2 = *argp2;
60558   {
60559     try {
60560       (arg1)->SetButtonImage(arg2);
60561     } catch (std::out_of_range& e) {
60562       {
60563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60564       };
60565     } catch (std::exception& e) {
60566       {
60567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60568       };
60569     } catch (...) {
60570       {
60571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60572       };
60573     }
60574   }
60575 }
60576
60577
60578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
60579   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60580   Dali::Image arg2 ;
60581   Dali::Image *argp2 ;
60582
60583   arg1 = (Dali::Toolkit::Button *)jarg1;
60584   argp2 = (Dali::Image *)jarg2;
60585   if (!argp2) {
60586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60587     return ;
60588   }
60589   arg2 = *argp2;
60590   {
60591     try {
60592       (arg1)->SetSelectedImage(arg2);
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60600       };
60601     } catch (...) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60604       };
60605     }
60606   }
60607 }
60608
60609
60610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
60611   void * jresult ;
60612   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60613   Dali::Actor result;
60614
60615   arg1 = (Dali::Toolkit::Button *)jarg1;
60616   {
60617     try {
60618       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
60619     } catch (std::out_of_range& e) {
60620       {
60621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60622       };
60623     } catch (std::exception& e) {
60624       {
60625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60626       };
60627     } catch (...) {
60628       {
60629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60630       };
60631     }
60632   }
60633   jresult = new Dali::Actor((const Dali::Actor &)result);
60634   return jresult;
60635 }
60636
60637
60638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
60639   void * jresult ;
60640   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60641   Dali::Actor result;
60642
60643   arg1 = (Dali::Toolkit::Button *)jarg1;
60644   {
60645     try {
60646       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
60647     } catch (std::out_of_range& e) {
60648       {
60649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60650       };
60651     } catch (std::exception& e) {
60652       {
60653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60654       };
60655     } catch (...) {
60656       {
60657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60658       };
60659     }
60660   }
60661   jresult = new Dali::Actor((const Dali::Actor &)result);
60662   return jresult;
60663 }
60664
60665
60666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
60667   void * jresult ;
60668   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60669   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60670
60671   arg1 = (Dali::Toolkit::Button *)jarg1;
60672   {
60673     try {
60674       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60686       };
60687     }
60688   }
60689   jresult = (void *)result;
60690   return jresult;
60691 }
60692
60693
60694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
60695   void * jresult ;
60696   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60697   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60698
60699   arg1 = (Dali::Toolkit::Button *)jarg1;
60700   {
60701     try {
60702       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
60703     } catch (std::out_of_range& e) {
60704       {
60705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60706       };
60707     } catch (std::exception& e) {
60708       {
60709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60710       };
60711     } catch (...) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60714       };
60715     }
60716   }
60717   jresult = (void *)result;
60718   return jresult;
60719 }
60720
60721
60722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
60723   void * jresult ;
60724   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60725   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60726
60727   arg1 = (Dali::Toolkit::Button *)jarg1;
60728   {
60729     try {
60730       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
60731     } catch (std::out_of_range& e) {
60732       {
60733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60734       };
60735     } catch (std::exception& e) {
60736       {
60737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (...) {
60740       {
60741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60742       };
60743     }
60744   }
60745   jresult = (void *)result;
60746   return jresult;
60747 }
60748
60749
60750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
60751   void * jresult ;
60752   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
60753   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
60754
60755   arg1 = (Dali::Toolkit::Button *)jarg1;
60756   {
60757     try {
60758       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
60759     } catch (std::out_of_range& e) {
60760       {
60761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60762       };
60763     } catch (std::exception& e) {
60764       {
60765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60766       };
60767     } catch (...) {
60768       {
60769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60770       };
60771     }
60772   }
60773   jresult = (void *)result;
60774   return jresult;
60775 }
60776
60777
60778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
60779   void * jresult ;
60780   Dali::Toolkit::CheckBoxButton *result = 0 ;
60781
60782   {
60783     try {
60784       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
60785     } catch (std::out_of_range& e) {
60786       {
60787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60788       };
60789     } catch (std::exception& e) {
60790       {
60791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60792       };
60793     } catch (...) {
60794       {
60795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60796       };
60797     }
60798   }
60799   jresult = (void *)result;
60800   return jresult;
60801 }
60802
60803
60804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
60805   void * jresult ;
60806   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
60807   Dali::Toolkit::CheckBoxButton *result = 0 ;
60808
60809   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60810   if (!arg1) {
60811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60812     return 0;
60813   }
60814   {
60815     try {
60816       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
60817     } catch (std::out_of_range& e) {
60818       {
60819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60820       };
60821     } catch (std::exception& e) {
60822       {
60823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (...) {
60826       {
60827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60828       };
60829     }
60830   }
60831   jresult = (void *)result;
60832   return jresult;
60833 }
60834
60835
60836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
60837   void * jresult ;
60838   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60839   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
60840   Dali::Toolkit::CheckBoxButton *result = 0 ;
60841
60842   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60843   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
60844   if (!arg2) {
60845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
60846     return 0;
60847   }
60848   {
60849     try {
60850       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
60851     } catch (std::out_of_range& e) {
60852       {
60853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (std::exception& e) {
60856       {
60857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60858       };
60859     } catch (...) {
60860       {
60861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60862       };
60863     }
60864   }
60865   jresult = (void *)result;
60866   return jresult;
60867 }
60868
60869
60870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
60871   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
60872
60873   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
60874   {
60875     try {
60876       delete arg1;
60877     } catch (std::out_of_range& e) {
60878       {
60879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60880       };
60881     } catch (std::exception& e) {
60882       {
60883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60884       };
60885     } catch (...) {
60886       {
60887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60888       };
60889     }
60890   }
60891 }
60892
60893
60894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
60895   void * jresult ;
60896   Dali::Toolkit::CheckBoxButton result;
60897
60898   {
60899     try {
60900       result = Dali::Toolkit::CheckBoxButton::New();
60901     } catch (std::out_of_range& e) {
60902       {
60903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60904       };
60905     } catch (std::exception& e) {
60906       {
60907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60908       };
60909     } catch (...) {
60910       {
60911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60912       };
60913     }
60914   }
60915   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
60921   void * jresult ;
60922   Dali::BaseHandle arg1 ;
60923   Dali::BaseHandle *argp1 ;
60924   Dali::Toolkit::CheckBoxButton result;
60925
60926   argp1 = (Dali::BaseHandle *)jarg1;
60927   if (!argp1) {
60928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60929     return 0;
60930   }
60931   arg1 = *argp1;
60932   {
60933     try {
60934       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
60935     } catch (std::out_of_range& e) {
60936       {
60937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60938       };
60939     } catch (std::exception& e) {
60940       {
60941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60942       };
60943     } catch (...) {
60944       {
60945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60946       };
60947     }
60948   }
60949   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
60950   return jresult;
60951 }
60952
60953
60954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
60955   int jresult ;
60956   int result;
60957
60958   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
60959   jresult = (int)result;
60960   return jresult;
60961 }
60962
60963
60964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
60965   int jresult ;
60966   int result;
60967
60968   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
60969   jresult = (int)result;
60970   return jresult;
60971 }
60972
60973
60974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
60975   int jresult ;
60976   int result;
60977
60978   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
60979   jresult = (int)result;
60980   return jresult;
60981 }
60982
60983
60984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
60985   int jresult ;
60986   int result;
60987
60988   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
60989   jresult = (int)result;
60990   return jresult;
60991 }
60992
60993
60994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
60995   int jresult ;
60996   int result;
60997
60998   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
60999   jresult = (int)result;
61000   return jresult;
61001 }
61002
61003
61004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
61005   void * jresult ;
61006   Dali::Toolkit::PushButton::Property *result = 0 ;
61007
61008   {
61009     try {
61010       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
61011     } catch (std::out_of_range& e) {
61012       {
61013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (std::exception& e) {
61016       {
61017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61018       };
61019     } catch (...) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61022       };
61023     }
61024   }
61025   jresult = (void *)result;
61026   return jresult;
61027 }
61028
61029
61030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
61031   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
61032
61033   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
61034   {
61035     try {
61036       delete arg1;
61037     } catch (std::out_of_range& e) {
61038       {
61039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61040       };
61041     } catch (std::exception& e) {
61042       {
61043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61044       };
61045     } catch (...) {
61046       {
61047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61048       };
61049     }
61050   }
61051 }
61052
61053
61054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
61055   void * jresult ;
61056   Dali::Toolkit::PushButton *result = 0 ;
61057
61058   {
61059     try {
61060       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
61061     } catch (std::out_of_range& e) {
61062       {
61063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61064       };
61065     } catch (std::exception& e) {
61066       {
61067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61068       };
61069     } catch (...) {
61070       {
61071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61072       };
61073     }
61074   }
61075   jresult = (void *)result;
61076   return jresult;
61077 }
61078
61079
61080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
61081   void * jresult ;
61082   Dali::Toolkit::PushButton *arg1 = 0 ;
61083   Dali::Toolkit::PushButton *result = 0 ;
61084
61085   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61086   if (!arg1) {
61087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
61088     return 0;
61089   }
61090   {
61091     try {
61092       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
61093     } catch (std::out_of_range& e) {
61094       {
61095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61096       };
61097     } catch (std::exception& e) {
61098       {
61099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61100       };
61101     } catch (...) {
61102       {
61103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61104       };
61105     }
61106   }
61107   jresult = (void *)result;
61108   return jresult;
61109 }
61110
61111
61112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
61113   void * jresult ;
61114   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61115   Dali::Toolkit::PushButton *arg2 = 0 ;
61116   Dali::Toolkit::PushButton *result = 0 ;
61117
61118   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61119   arg2 = (Dali::Toolkit::PushButton *)jarg2;
61120   if (!arg2) {
61121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
61122     return 0;
61123   }
61124   {
61125     try {
61126       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
61127     } catch (std::out_of_range& e) {
61128       {
61129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61130       };
61131     } catch (std::exception& e) {
61132       {
61133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61134       };
61135     } catch (...) {
61136       {
61137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61138       };
61139     }
61140   }
61141   jresult = (void *)result;
61142   return jresult;
61143 }
61144
61145
61146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
61147   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61148
61149   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61150   {
61151     try {
61152       delete arg1;
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_New() {
61171   void * jresult ;
61172   Dali::Toolkit::PushButton result;
61173
61174   {
61175     try {
61176       result = Dali::Toolkit::PushButton::New();
61177     } catch (std::out_of_range& e) {
61178       {
61179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61180       };
61181     } catch (std::exception& e) {
61182       {
61183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61184       };
61185     } catch (...) {
61186       {
61187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61188       };
61189     }
61190   }
61191   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61192   return jresult;
61193 }
61194
61195
61196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
61197   void * jresult ;
61198   Dali::BaseHandle arg1 ;
61199   Dali::BaseHandle *argp1 ;
61200   Dali::Toolkit::PushButton result;
61201
61202   argp1 = (Dali::BaseHandle *)jarg1;
61203   if (!argp1) {
61204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61205     return 0;
61206   }
61207   arg1 = *argp1;
61208   {
61209     try {
61210       result = Dali::Toolkit::PushButton::DownCast(arg1);
61211     } catch (std::out_of_range& e) {
61212       {
61213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61214       };
61215     } catch (std::exception& e) {
61216       {
61217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61218       };
61219     } catch (...) {
61220       {
61221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61222       };
61223     }
61224   }
61225   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
61226   return jresult;
61227 }
61228
61229
61230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
61231   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61232   Dali::Image arg2 ;
61233   Dali::Image *argp2 ;
61234
61235   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61236   argp2 = (Dali::Image *)jarg2;
61237   if (!argp2) {
61238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61239     return ;
61240   }
61241   arg2 = *argp2;
61242   {
61243     try {
61244       (arg1)->SetButtonImage(arg2);
61245     } catch (std::out_of_range& e) {
61246       {
61247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61248       };
61249     } catch (std::exception& e) {
61250       {
61251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61252       };
61253     } catch (...) {
61254       {
61255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61256       };
61257     }
61258   }
61259 }
61260
61261
61262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
61263   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61264   Dali::Actor arg2 ;
61265   Dali::Actor *argp2 ;
61266
61267   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61268   argp2 = (Dali::Actor *)jarg2;
61269   if (!argp2) {
61270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61271     return ;
61272   }
61273   arg2 = *argp2;
61274   {
61275     try {
61276       (arg1)->SetButtonImage(arg2);
61277     } catch (std::out_of_range& e) {
61278       {
61279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61280       };
61281     } catch (std::exception& e) {
61282       {
61283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61284       };
61285     } catch (...) {
61286       {
61287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61288       };
61289     }
61290   }
61291 }
61292
61293
61294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
61295   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61296   Dali::Actor arg2 ;
61297   Dali::Actor *argp2 ;
61298
61299   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61300   argp2 = (Dali::Actor *)jarg2;
61301   if (!argp2) {
61302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61303     return ;
61304   }
61305   arg2 = *argp2;
61306   {
61307     try {
61308       (arg1)->SetBackgroundImage(arg2);
61309     } catch (std::out_of_range& e) {
61310       {
61311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61312       };
61313     } catch (std::exception& e) {
61314       {
61315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61316       };
61317     } catch (...) {
61318       {
61319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61320       };
61321     }
61322   }
61323 }
61324
61325
61326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
61327   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61328   Dali::Image arg2 ;
61329   Dali::Image *argp2 ;
61330
61331   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61332   argp2 = (Dali::Image *)jarg2;
61333   if (!argp2) {
61334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61335     return ;
61336   }
61337   arg2 = *argp2;
61338   {
61339     try {
61340       (arg1)->SetSelectedImage(arg2);
61341     } catch (std::out_of_range& e) {
61342       {
61343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61344       };
61345     } catch (std::exception& e) {
61346       {
61347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61348       };
61349     } catch (...) {
61350       {
61351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61352       };
61353     }
61354   }
61355 }
61356
61357
61358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
61359   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61360   Dali::Actor arg2 ;
61361   Dali::Actor *argp2 ;
61362
61363   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61364   argp2 = (Dali::Actor *)jarg2;
61365   if (!argp2) {
61366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61367     return ;
61368   }
61369   arg2 = *argp2;
61370   {
61371     try {
61372       (arg1)->SetSelectedImage(arg2);
61373     } catch (std::out_of_range& e) {
61374       {
61375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61376       };
61377     } catch (std::exception& e) {
61378       {
61379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61380       };
61381     } catch (...) {
61382       {
61383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61384       };
61385     }
61386   }
61387 }
61388
61389
61390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
61391   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61392   Dali::Actor arg2 ;
61393   Dali::Actor *argp2 ;
61394
61395   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61396   argp2 = (Dali::Actor *)jarg2;
61397   if (!argp2) {
61398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61399     return ;
61400   }
61401   arg2 = *argp2;
61402   {
61403     try {
61404       (arg1)->SetSelectedBackgroundImage(arg2);
61405     } catch (std::out_of_range& e) {
61406       {
61407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61408       };
61409     } catch (std::exception& e) {
61410       {
61411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61412       };
61413     } catch (...) {
61414       {
61415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61416       };
61417     }
61418   }
61419 }
61420
61421
61422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
61423   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61424   Dali::Actor arg2 ;
61425   Dali::Actor *argp2 ;
61426
61427   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61428   argp2 = (Dali::Actor *)jarg2;
61429   if (!argp2) {
61430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61431     return ;
61432   }
61433   arg2 = *argp2;
61434   {
61435     try {
61436       (arg1)->SetDisabledBackgroundImage(arg2);
61437     } catch (std::out_of_range& e) {
61438       {
61439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61440       };
61441     } catch (std::exception& e) {
61442       {
61443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61444       };
61445     } catch (...) {
61446       {
61447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61448       };
61449     }
61450   }
61451 }
61452
61453
61454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
61455   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61456   Dali::Actor arg2 ;
61457   Dali::Actor *argp2 ;
61458
61459   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61460   argp2 = (Dali::Actor *)jarg2;
61461   if (!argp2) {
61462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61463     return ;
61464   }
61465   arg2 = *argp2;
61466   {
61467     try {
61468       (arg1)->SetDisabledImage(arg2);
61469     } catch (std::out_of_range& e) {
61470       {
61471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61472       };
61473     } catch (std::exception& e) {
61474       {
61475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61476       };
61477     } catch (...) {
61478       {
61479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61480       };
61481     }
61482   }
61483 }
61484
61485
61486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
61487   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
61488   Dali::Actor arg2 ;
61489   Dali::Actor *argp2 ;
61490
61491   arg1 = (Dali::Toolkit::PushButton *)jarg1;
61492   argp2 = (Dali::Actor *)jarg2;
61493   if (!argp2) {
61494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61495     return ;
61496   }
61497   arg2 = *argp2;
61498   {
61499     try {
61500       (arg1)->SetDisabledSelectedImage(arg2);
61501     } catch (std::out_of_range& e) {
61502       {
61503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61504       };
61505     } catch (std::exception& e) {
61506       {
61507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61508       };
61509     } catch (...) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61512       };
61513     }
61514   }
61515 }
61516
61517
61518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
61519   void * jresult ;
61520   Dali::Toolkit::RadioButton *result = 0 ;
61521
61522   {
61523     try {
61524       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
61525     } catch (std::out_of_range& e) {
61526       {
61527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61528       };
61529     } catch (std::exception& e) {
61530       {
61531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61532       };
61533     } catch (...) {
61534       {
61535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61536       };
61537     }
61538   }
61539   jresult = (void *)result;
61540   return jresult;
61541 }
61542
61543
61544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
61545   void * jresult ;
61546   Dali::Toolkit::RadioButton *arg1 = 0 ;
61547   Dali::Toolkit::RadioButton *result = 0 ;
61548
61549   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61550   if (!arg1) {
61551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61552     return 0;
61553   }
61554   {
61555     try {
61556       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
61557     } catch (std::out_of_range& e) {
61558       {
61559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61560       };
61561     } catch (std::exception& e) {
61562       {
61563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61564       };
61565     } catch (...) {
61566       {
61567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61568       };
61569     }
61570   }
61571   jresult = (void *)result;
61572   return jresult;
61573 }
61574
61575
61576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
61577   void * jresult ;
61578   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61579   Dali::Toolkit::RadioButton *arg2 = 0 ;
61580   Dali::Toolkit::RadioButton *result = 0 ;
61581
61582   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61583   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
61584   if (!arg2) {
61585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
61586     return 0;
61587   }
61588   {
61589     try {
61590       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
61591     } catch (std::out_of_range& e) {
61592       {
61593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61594       };
61595     } catch (std::exception& e) {
61596       {
61597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61598       };
61599     } catch (...) {
61600       {
61601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61602       };
61603     }
61604   }
61605   jresult = (void *)result;
61606   return jresult;
61607 }
61608
61609
61610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
61611   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
61612
61613   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
61614   {
61615     try {
61616       delete arg1;
61617     } catch (std::out_of_range& e) {
61618       {
61619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61620       };
61621     } catch (std::exception& e) {
61622       {
61623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61624       };
61625     } catch (...) {
61626       {
61627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61628       };
61629     }
61630   }
61631 }
61632
61633
61634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
61635   void * jresult ;
61636   Dali::Toolkit::RadioButton result;
61637
61638   {
61639     try {
61640       result = Dali::Toolkit::RadioButton::New();
61641     } catch (std::out_of_range& e) {
61642       {
61643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61644       };
61645     } catch (std::exception& e) {
61646       {
61647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61648       };
61649     } catch (...) {
61650       {
61651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61652       };
61653     }
61654   }
61655   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61656   return jresult;
61657 }
61658
61659
61660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
61661   void * jresult ;
61662   std::string *arg1 = 0 ;
61663   Dali::Toolkit::RadioButton result;
61664
61665   if (!jarg1) {
61666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61667     return 0;
61668   }
61669   std::string arg1_str(jarg1);
61670   arg1 = &arg1_str;
61671   {
61672     try {
61673       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
61674     } catch (std::out_of_range& e) {
61675       {
61676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (std::exception& e) {
61679       {
61680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (...) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61685       };
61686     }
61687   }
61688   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61689
61690   //argout typemap for const std::string&
61691
61692   return jresult;
61693 }
61694
61695
61696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
61697   void * jresult ;
61698   Dali::BaseHandle arg1 ;
61699   Dali::BaseHandle *argp1 ;
61700   Dali::Toolkit::RadioButton result;
61701
61702   argp1 = (Dali::BaseHandle *)jarg1;
61703   if (!argp1) {
61704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61705     return 0;
61706   }
61707   arg1 = *argp1;
61708   {
61709     try {
61710       result = Dali::Toolkit::RadioButton::DownCast(arg1);
61711     } catch (std::out_of_range& e) {
61712       {
61713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61714       };
61715     } catch (std::exception& e) {
61716       {
61717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61718       };
61719     } catch (...) {
61720       {
61721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61722       };
61723     }
61724   }
61725   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
61726   return jresult;
61727 }
61728
61729
61730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
61731   int jresult ;
61732   int result;
61733
61734   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
61735   jresult = (int)result;
61736   return jresult;
61737 }
61738
61739
61740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
61741   int jresult ;
61742   int result;
61743
61744   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
61745   jresult = (int)result;
61746   return jresult;
61747 }
61748
61749
61750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
61751   int jresult ;
61752   int result;
61753
61754   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
61755   jresult = (int)result;
61756   return jresult;
61757 }
61758
61759
61760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
61761   int jresult ;
61762   int result;
61763
61764   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
61765   jresult = (int)result;
61766   return jresult;
61767 }
61768
61769
61770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
61771   int jresult ;
61772   int result;
61773
61774   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
61775   jresult = (int)result;
61776   return jresult;
61777 }
61778
61779
61780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
61781   int jresult ;
61782   int result;
61783
61784   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
61785   jresult = (int)result;
61786   return jresult;
61787 }
61788
61789
61790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
61791   void * jresult ;
61792   Dali::Toolkit::FlexContainer::Property *result = 0 ;
61793
61794   {
61795     try {
61796       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
61797     } catch (std::out_of_range& e) {
61798       {
61799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61800       };
61801     } catch (std::exception& e) {
61802       {
61803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61804       };
61805     } catch (...) {
61806       {
61807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61808       };
61809     }
61810   }
61811   jresult = (void *)result;
61812   return jresult;
61813 }
61814
61815
61816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
61817   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
61818
61819   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
61820   {
61821     try {
61822       delete arg1;
61823     } catch (std::out_of_range& e) {
61824       {
61825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61826       };
61827     } catch (std::exception& e) {
61828       {
61829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61830       };
61831     } catch (...) {
61832       {
61833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61834       };
61835     }
61836   }
61837 }
61838
61839
61840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
61841   int jresult ;
61842   int result;
61843
61844   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
61845   jresult = (int)result;
61846   return jresult;
61847 }
61848
61849
61850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
61851   int jresult ;
61852   int result;
61853
61854   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
61855   jresult = (int)result;
61856   return jresult;
61857 }
61858
61859
61860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
61861   int jresult ;
61862   int result;
61863
61864   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
61865   jresult = (int)result;
61866   return jresult;
61867 }
61868
61869
61870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
61871   void * jresult ;
61872   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
61873
61874   {
61875     try {
61876       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
61877     } catch (std::out_of_range& e) {
61878       {
61879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61880       };
61881     } catch (std::exception& e) {
61882       {
61883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61884       };
61885     } catch (...) {
61886       {
61887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61888       };
61889     }
61890   }
61891   jresult = (void *)result;
61892   return jresult;
61893 }
61894
61895
61896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
61897   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
61898
61899   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
61900   {
61901     try {
61902       delete arg1;
61903     } catch (std::out_of_range& e) {
61904       {
61905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61906       };
61907     } catch (std::exception& e) {
61908       {
61909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61910       };
61911     } catch (...) {
61912       {
61913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61914       };
61915     }
61916   }
61917 }
61918
61919
61920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
61921   void * jresult ;
61922   Dali::Toolkit::FlexContainer *result = 0 ;
61923
61924   {
61925     try {
61926       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
61927     } catch (std::out_of_range& e) {
61928       {
61929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61930       };
61931     } catch (std::exception& e) {
61932       {
61933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61934       };
61935     } catch (...) {
61936       {
61937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61938       };
61939     }
61940   }
61941   jresult = (void *)result;
61942   return jresult;
61943 }
61944
61945
61946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
61947   void * jresult ;
61948   Dali::Toolkit::FlexContainer *arg1 = 0 ;
61949   Dali::Toolkit::FlexContainer *result = 0 ;
61950
61951   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61952   if (!arg1) {
61953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61954     return 0;
61955   }
61956   {
61957     try {
61958       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
61959     } catch (std::out_of_range& e) {
61960       {
61961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61962       };
61963     } catch (std::exception& e) {
61964       {
61965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61966       };
61967     } catch (...) {
61968       {
61969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61970       };
61971     }
61972   }
61973   jresult = (void *)result;
61974   return jresult;
61975 }
61976
61977
61978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
61979   void * jresult ;
61980   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
61981   Dali::Toolkit::FlexContainer *arg2 = 0 ;
61982   Dali::Toolkit::FlexContainer *result = 0 ;
61983
61984   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
61985   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
61986   if (!arg2) {
61987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
61988     return 0;
61989   }
61990   {
61991     try {
61992       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
61993     } catch (std::out_of_range& e) {
61994       {
61995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61996       };
61997     } catch (std::exception& e) {
61998       {
61999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62000       };
62001     } catch (...) {
62002       {
62003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62004       };
62005     }
62006   }
62007   jresult = (void *)result;
62008   return jresult;
62009 }
62010
62011
62012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
62013   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
62014
62015   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
62016   {
62017     try {
62018       delete arg1;
62019     } catch (std::out_of_range& e) {
62020       {
62021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62022       };
62023     } catch (std::exception& e) {
62024       {
62025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62026       };
62027     } catch (...) {
62028       {
62029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62030       };
62031     }
62032   }
62033 }
62034
62035
62036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
62037   void * jresult ;
62038   Dali::Toolkit::FlexContainer result;
62039
62040   {
62041     try {
62042       result = Dali::Toolkit::FlexContainer::New();
62043     } catch (std::out_of_range& e) {
62044       {
62045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62046       };
62047     } catch (std::exception& e) {
62048       {
62049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62050       };
62051     } catch (...) {
62052       {
62053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62054       };
62055     }
62056   }
62057   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
62058   return jresult;
62059 }
62060
62061
62062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
62063   void * jresult ;
62064   Dali::BaseHandle arg1 ;
62065   Dali::BaseHandle *argp1 ;
62066   Dali::Toolkit::FlexContainer result;
62067
62068   argp1 = (Dali::BaseHandle *)jarg1;
62069   if (!argp1) {
62070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62071     return 0;
62072   }
62073   arg1 = *argp1;
62074   {
62075     try {
62076       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
62077     } catch (std::out_of_range& e) {
62078       {
62079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62080       };
62081     } catch (std::exception& e) {
62082       {
62083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62084       };
62085     } catch (...) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62088       };
62089     }
62090   }
62091   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
62092   return jresult;
62093 }
62094
62095
62096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
62097   int jresult ;
62098   int result;
62099
62100   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
62101   jresult = (int)result;
62102   return jresult;
62103 }
62104
62105
62106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
62107   int jresult ;
62108   int result;
62109
62110   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
62111   jresult = (int)result;
62112   return jresult;
62113 }
62114
62115
62116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
62117   int jresult ;
62118   int result;
62119
62120   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
62121   jresult = (int)result;
62122   return jresult;
62123 }
62124
62125
62126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
62127   int jresult ;
62128   int result;
62129
62130   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
62131   jresult = (int)result;
62132   return jresult;
62133 }
62134
62135
62136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
62137   void * jresult ;
62138   Dali::Toolkit::ImageView::Property *result = 0 ;
62139
62140   {
62141     try {
62142       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
62143     } catch (std::out_of_range& e) {
62144       {
62145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (std::exception& e) {
62148       {
62149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (...) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62154       };
62155     }
62156   }
62157   jresult = (void *)result;
62158   return jresult;
62159 }
62160
62161
62162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
62163   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
62164
62165   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
62166   {
62167     try {
62168       delete arg1;
62169     } catch (std::out_of_range& e) {
62170       {
62171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62172       };
62173     } catch (std::exception& e) {
62174       {
62175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62176       };
62177     } catch (...) {
62178       {
62179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62180       };
62181     }
62182   }
62183 }
62184
62185
62186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
62187   void * jresult ;
62188   Dali::Toolkit::ImageView *result = 0 ;
62189
62190   {
62191     try {
62192       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
62193     } catch (std::out_of_range& e) {
62194       {
62195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62196       };
62197     } catch (std::exception& e) {
62198       {
62199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62200       };
62201     } catch (...) {
62202       {
62203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62204       };
62205     }
62206   }
62207   jresult = (void *)result;
62208   return jresult;
62209 }
62210
62211
62212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
62213   void * jresult ;
62214   Dali::Toolkit::ImageView result;
62215
62216   {
62217     try {
62218       result = Dali::Toolkit::ImageView::New();
62219     } catch (std::out_of_range& e) {
62220       {
62221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62222       };
62223     } catch (std::exception& e) {
62224       {
62225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62226       };
62227     } catch (...) {
62228       {
62229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62230       };
62231     }
62232   }
62233   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62234   return jresult;
62235 }
62236
62237
62238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
62239   void * jresult ;
62240   Dali::Image arg1 ;
62241   Dali::Image *argp1 ;
62242   Dali::Toolkit::ImageView result;
62243
62244   argp1 = (Dali::Image *)jarg1;
62245   if (!argp1) {
62246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62247     return 0;
62248   }
62249   arg1 = *argp1;
62250   {
62251     try {
62252       result = Dali::Toolkit::ImageView::New(arg1);
62253     } catch (std::out_of_range& e) {
62254       {
62255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62256       };
62257     } catch (std::exception& e) {
62258       {
62259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62260       };
62261     } catch (...) {
62262       {
62263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62264       };
62265     }
62266   }
62267   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62268   return jresult;
62269 }
62270
62271
62272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
62273   void * jresult ;
62274   std::string *arg1 = 0 ;
62275   Dali::Toolkit::ImageView result;
62276
62277   if (!jarg1) {
62278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62279     return 0;
62280   }
62281   std::string arg1_str(jarg1);
62282   arg1 = &arg1_str;
62283   {
62284     try {
62285       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
62286     } catch (std::out_of_range& e) {
62287       {
62288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62289       };
62290     } catch (std::exception& e) {
62291       {
62292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62293       };
62294     } catch (...) {
62295       {
62296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62297       };
62298     }
62299   }
62300   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62301
62302   //argout typemap for const std::string&
62303
62304   return jresult;
62305 }
62306
62307
62308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
62309   void * jresult ;
62310   std::string *arg1 = 0 ;
62311   Dali::ImageDimensions arg2 ;
62312   Dali::ImageDimensions *argp2 ;
62313   Dali::Toolkit::ImageView result;
62314
62315   if (!jarg1) {
62316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62317     return 0;
62318   }
62319   std::string arg1_str(jarg1);
62320   arg1 = &arg1_str;
62321   argp2 = (Dali::ImageDimensions *)jarg2;
62322   if (!argp2) {
62323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62324     return 0;
62325   }
62326   arg2 = *argp2;
62327   {
62328     try {
62329       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
62330     } catch (std::out_of_range& e) {
62331       {
62332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62333       };
62334     } catch (std::exception& e) {
62335       {
62336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62337       };
62338     } catch (...) {
62339       {
62340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62341       };
62342     }
62343   }
62344   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62345
62346   //argout typemap for const std::string&
62347
62348   return jresult;
62349 }
62350
62351
62352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
62353   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62354
62355   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62356   {
62357     try {
62358       delete arg1;
62359     } catch (std::out_of_range& e) {
62360       {
62361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62362       };
62363     } catch (std::exception& e) {
62364       {
62365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62366       };
62367     } catch (...) {
62368       {
62369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62370       };
62371     }
62372   }
62373 }
62374
62375
62376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
62377   void * jresult ;
62378   Dali::Toolkit::ImageView *arg1 = 0 ;
62379   Dali::Toolkit::ImageView *result = 0 ;
62380
62381   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62382   if (!arg1) {
62383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62384     return 0;
62385   }
62386   {
62387     try {
62388       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
62389     } catch (std::out_of_range& e) {
62390       {
62391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62392       };
62393     } catch (std::exception& e) {
62394       {
62395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62396       };
62397     } catch (...) {
62398       {
62399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62400       };
62401     }
62402   }
62403   jresult = (void *)result;
62404   return jresult;
62405 }
62406
62407
62408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
62409   void * jresult ;
62410   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62411   Dali::Toolkit::ImageView *arg2 = 0 ;
62412   Dali::Toolkit::ImageView *result = 0 ;
62413
62414   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62415   arg2 = (Dali::Toolkit::ImageView *)jarg2;
62416   if (!arg2) {
62417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
62418     return 0;
62419   }
62420   {
62421     try {
62422       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
62423     } catch (std::out_of_range& e) {
62424       {
62425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62426       };
62427     } catch (std::exception& e) {
62428       {
62429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (...) {
62432       {
62433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62434       };
62435     }
62436   }
62437   jresult = (void *)result;
62438   return jresult;
62439 }
62440
62441
62442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
62443   void * jresult ;
62444   Dali::BaseHandle arg1 ;
62445   Dali::BaseHandle *argp1 ;
62446   Dali::Toolkit::ImageView result;
62447
62448   argp1 = (Dali::BaseHandle *)jarg1;
62449   if (!argp1) {
62450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62451     return 0;
62452   }
62453   arg1 = *argp1;
62454   {
62455     try {
62456       result = Dali::Toolkit::ImageView::DownCast(arg1);
62457     } catch (std::out_of_range& e) {
62458       {
62459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62460       };
62461     } catch (std::exception& e) {
62462       {
62463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62464       };
62465     } catch (...) {
62466       {
62467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62468       };
62469     }
62470   }
62471   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
62472   return jresult;
62473 }
62474
62475
62476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
62477   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62478   Dali::Image arg2 ;
62479   Dali::Image *argp2 ;
62480
62481   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62482   argp2 = (Dali::Image *)jarg2;
62483   if (!argp2) {
62484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62485     return ;
62486   }
62487   arg2 = *argp2;
62488   {
62489     try {
62490       (arg1)->SetImage(arg2);
62491     } catch (std::out_of_range& e) {
62492       {
62493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62494       };
62495     } catch (std::exception& e) {
62496       {
62497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62498       };
62499     } catch (...) {
62500       {
62501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62502       };
62503     }
62504   }
62505 }
62506
62507
62508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
62509   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62510   std::string *arg2 = 0 ;
62511
62512   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62513   if (!jarg2) {
62514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62515     return ;
62516   }
62517   std::string arg2_str(jarg2);
62518   arg2 = &arg2_str;
62519   {
62520     try {
62521       (arg1)->SetImage((std::string const &)*arg2);
62522     } catch (std::out_of_range& e) {
62523       {
62524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62525       };
62526     } catch (std::exception& e) {
62527       {
62528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62529       };
62530     } catch (...) {
62531       {
62532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62533       };
62534     }
62535   }
62536
62537   //argout typemap for const std::string&
62538
62539 }
62540
62541
62542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62543   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62544   std::string *arg2 = 0 ;
62545   Dali::ImageDimensions arg3 ;
62546   Dali::ImageDimensions *argp3 ;
62547
62548   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62549   if (!jarg2) {
62550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62551     return ;
62552   }
62553   std::string arg2_str(jarg2);
62554   arg2 = &arg2_str;
62555   argp3 = (Dali::ImageDimensions *)jarg3;
62556   if (!argp3) {
62557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
62558     return ;
62559   }
62560   arg3 = *argp3;
62561   {
62562     try {
62563       (arg1)->SetImage((std::string const &)*arg2,arg3);
62564     } catch (std::out_of_range& e) {
62565       {
62566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62567       };
62568     } catch (std::exception& e) {
62569       {
62570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62571       };
62572     } catch (...) {
62573       {
62574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62575       };
62576     }
62577   }
62578
62579   //argout typemap for const std::string&
62580
62581 }
62582
62583
62584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
62585   void * jresult ;
62586   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
62587   Dali::Image result;
62588
62589   arg1 = (Dali::Toolkit::ImageView *)jarg1;
62590   {
62591     try {
62592       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
62593     } catch (std::out_of_range& e) {
62594       {
62595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62596       };
62597     } catch (std::exception& e) {
62598       {
62599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62600       };
62601     } catch (...) {
62602       {
62603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62604       };
62605     }
62606   }
62607   jresult = new Dali::Image((const Dali::Image &)result);
62608   return jresult;
62609 }
62610
62611
62612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
62613   int jresult ;
62614   int result;
62615
62616   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
62617   jresult = (int)result;
62618   return jresult;
62619 }
62620
62621
62622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
62623   int jresult ;
62624   int result;
62625
62626   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
62627   jresult = (int)result;
62628   return jresult;
62629 }
62630
62631
62632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
62633   int jresult ;
62634   int result;
62635
62636   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
62637   jresult = (int)result;
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
62643   int jresult ;
62644   int result;
62645
62646   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
62647   jresult = (int)result;
62648   return jresult;
62649 }
62650
62651
62652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
62653   int jresult ;
62654   int result;
62655
62656   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
62657   jresult = (int)result;
62658   return jresult;
62659 }
62660
62661
62662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
62663   int jresult ;
62664   int result;
62665
62666   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
62667   jresult = (int)result;
62668   return jresult;
62669 }
62670
62671
62672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
62673   int jresult ;
62674   int result;
62675
62676   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
62677   jresult = (int)result;
62678   return jresult;
62679 }
62680
62681
62682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
62683   int jresult ;
62684   int result;
62685
62686   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
62687   jresult = (int)result;
62688   return jresult;
62689 }
62690
62691
62692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
62693   void * jresult ;
62694   Dali::Toolkit::Model3dView::Property *result = 0 ;
62695
62696   {
62697     try {
62698       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
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_delete_Model3dView_Property(void * jarg1) {
62719   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
62720
62721   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
62722   {
62723     try {
62724       delete arg1;
62725     } catch (std::out_of_range& e) {
62726       {
62727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62728       };
62729     } catch (std::exception& e) {
62730       {
62731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62732       };
62733     } catch (...) {
62734       {
62735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62736       };
62737     }
62738   }
62739 }
62740
62741
62742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
62743   void * jresult ;
62744   Dali::Toolkit::Model3dView result;
62745
62746   {
62747     try {
62748       result = Dali::Toolkit::Model3dView::New();
62749     } catch (std::out_of_range& e) {
62750       {
62751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62752       };
62753     } catch (std::exception& e) {
62754       {
62755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62756       };
62757     } catch (...) {
62758       {
62759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62760       };
62761     }
62762   }
62763   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62764   return jresult;
62765 }
62766
62767
62768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
62769   void * jresult ;
62770   std::string *arg1 = 0 ;
62771   std::string *arg2 = 0 ;
62772   std::string *arg3 = 0 ;
62773   Dali::Toolkit::Model3dView result;
62774
62775   if (!jarg1) {
62776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62777     return 0;
62778   }
62779   std::string arg1_str(jarg1);
62780   arg1 = &arg1_str;
62781   if (!jarg2) {
62782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62783     return 0;
62784   }
62785   std::string arg2_str(jarg2);
62786   arg2 = &arg2_str;
62787   if (!jarg3) {
62788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62789     return 0;
62790   }
62791   std::string arg3_str(jarg3);
62792   arg3 = &arg3_str;
62793   {
62794     try {
62795       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
62796     } catch (std::out_of_range& e) {
62797       {
62798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (std::exception& e) {
62801       {
62802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62803       };
62804     } catch (...) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62807       };
62808     }
62809   }
62810   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62811
62812   //argout typemap for const std::string&
62813
62814
62815   //argout typemap for const std::string&
62816
62817
62818   //argout typemap for const std::string&
62819
62820   return jresult;
62821 }
62822
62823
62824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
62825   void * jresult ;
62826   Dali::Toolkit::Model3dView *result = 0 ;
62827
62828   {
62829     try {
62830       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
62831     } catch (std::out_of_range& e) {
62832       {
62833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (std::exception& e) {
62836       {
62837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845   jresult = (void *)result;
62846   return jresult;
62847 }
62848
62849
62850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
62851   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62852
62853   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62854   {
62855     try {
62856       delete arg1;
62857     } catch (std::out_of_range& e) {
62858       {
62859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62860       };
62861     } catch (std::exception& e) {
62862       {
62863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62864       };
62865     } catch (...) {
62866       {
62867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62868       };
62869     }
62870   }
62871 }
62872
62873
62874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
62875   void * jresult ;
62876   Dali::Toolkit::Model3dView *arg1 = 0 ;
62877   Dali::Toolkit::Model3dView *result = 0 ;
62878
62879   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62880   if (!arg1) {
62881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62882     return 0;
62883   }
62884   {
62885     try {
62886       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
62887     } catch (std::out_of_range& e) {
62888       {
62889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62890       };
62891     } catch (std::exception& e) {
62892       {
62893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62894       };
62895     } catch (...) {
62896       {
62897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62898       };
62899     }
62900   }
62901   jresult = (void *)result;
62902   return jresult;
62903 }
62904
62905
62906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
62907   void * jresult ;
62908   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
62909   Dali::Toolkit::Model3dView *arg2 = 0 ;
62910   Dali::Toolkit::Model3dView *result = 0 ;
62911
62912   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
62913   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
62914   if (!arg2) {
62915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
62916     return 0;
62917   }
62918   {
62919     try {
62920       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
62921     } catch (std::out_of_range& e) {
62922       {
62923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62924       };
62925     } catch (std::exception& e) {
62926       {
62927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62928       };
62929     } catch (...) {
62930       {
62931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62932       };
62933     }
62934   }
62935   jresult = (void *)result;
62936   return jresult;
62937 }
62938
62939
62940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
62941   void * jresult ;
62942   Dali::BaseHandle arg1 ;
62943   Dali::BaseHandle *argp1 ;
62944   Dali::Toolkit::Model3dView result;
62945
62946   argp1 = (Dali::BaseHandle *)jarg1;
62947   if (!argp1) {
62948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62949     return 0;
62950   }
62951   arg1 = *argp1;
62952   {
62953     try {
62954       result = Dali::Toolkit::Model3dView::DownCast(arg1);
62955     } catch (std::out_of_range& e) {
62956       {
62957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62958       };
62959     } catch (std::exception& e) {
62960       {
62961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62966       };
62967     }
62968   }
62969   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
62970   return jresult;
62971 }
62972
62973
62974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
62975   int jresult ;
62976   int result;
62977
62978   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
62979   jresult = (int)result;
62980   return jresult;
62981 }
62982
62983
62984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
62985   int jresult ;
62986   int result;
62987
62988   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
62989   jresult = (int)result;
62990   return jresult;
62991 }
62992
62993
62994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
62995   int jresult ;
62996   int result;
62997
62998   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
62999   jresult = (int)result;
63000   return jresult;
63001 }
63002
63003
63004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
63005   int jresult ;
63006   int result;
63007
63008   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
63009   jresult = (int)result;
63010   return jresult;
63011 }
63012
63013
63014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
63015   int jresult ;
63016   int result;
63017
63018   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
63019   jresult = (int)result;
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
63025   int jresult ;
63026   int result;
63027
63028   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
63029   jresult = (int)result;
63030   return jresult;
63031 }
63032
63033
63034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
63035   int jresult ;
63036   int result;
63037
63038   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
63039   jresult = (int)result;
63040   return jresult;
63041 }
63042
63043
63044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
63045   int jresult ;
63046   int result;
63047
63048   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
63049   jresult = (int)result;
63050   return jresult;
63051 }
63052
63053
63054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
63055   int jresult ;
63056   int result;
63057
63058   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
63059   jresult = (int)result;
63060   return jresult;
63061 }
63062
63063
63064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
63065   void * jresult ;
63066   Dali::Toolkit::ScrollBar::Property *result = 0 ;
63067
63068   {
63069     try {
63070       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
63071     } catch (std::out_of_range& e) {
63072       {
63073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63074       };
63075     } catch (std::exception& e) {
63076       {
63077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63082       };
63083     }
63084   }
63085   jresult = (void *)result;
63086   return jresult;
63087 }
63088
63089
63090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
63091   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
63092
63093   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
63094   {
63095     try {
63096       delete arg1;
63097     } catch (std::out_of_range& e) {
63098       {
63099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63100       };
63101     } catch (std::exception& e) {
63102       {
63103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63108       };
63109     }
63110   }
63111 }
63112
63113
63114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
63115   void * jresult ;
63116   Dali::Toolkit::ScrollBar *result = 0 ;
63117
63118   {
63119     try {
63120       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
63121     } catch (std::out_of_range& e) {
63122       {
63123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63124       };
63125     } catch (std::exception& e) {
63126       {
63127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63128       };
63129     } catch (...) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63132       };
63133     }
63134   }
63135   jresult = (void *)result;
63136   return jresult;
63137 }
63138
63139
63140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
63141   void * jresult ;
63142   Dali::Toolkit::ScrollBar *arg1 = 0 ;
63143   Dali::Toolkit::ScrollBar *result = 0 ;
63144
63145   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63146   if (!arg1) {
63147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63148     return 0;
63149   }
63150   {
63151     try {
63152       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
63153     } catch (std::out_of_range& e) {
63154       {
63155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63156       };
63157     } catch (std::exception& e) {
63158       {
63159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63160       };
63161     } catch (...) {
63162       {
63163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63164       };
63165     }
63166   }
63167   jresult = (void *)result;
63168   return jresult;
63169 }
63170
63171
63172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
63173   void * jresult ;
63174   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63175   Dali::Toolkit::ScrollBar *arg2 = 0 ;
63176   Dali::Toolkit::ScrollBar *result = 0 ;
63177
63178   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63179   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
63180   if (!arg2) {
63181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
63182     return 0;
63183   }
63184   {
63185     try {
63186       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
63187     } catch (std::out_of_range& e) {
63188       {
63189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63190       };
63191     } catch (std::exception& e) {
63192       {
63193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (...) {
63196       {
63197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63198       };
63199     }
63200   }
63201   jresult = (void *)result;
63202   return jresult;
63203 }
63204
63205
63206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
63207   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63208
63209   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63210   {
63211     try {
63212       delete arg1;
63213     } catch (std::out_of_range& e) {
63214       {
63215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63216       };
63217     } catch (std::exception& e) {
63218       {
63219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63220       };
63221     } catch (...) {
63222       {
63223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63224       };
63225     }
63226   }
63227 }
63228
63229
63230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
63231   void * jresult ;
63232   Dali::Toolkit::ScrollBar::Direction arg1 ;
63233   Dali::Toolkit::ScrollBar result;
63234
63235   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
63236   {
63237     try {
63238       result = Dali::Toolkit::ScrollBar::New(arg1);
63239     } catch (std::out_of_range& e) {
63240       {
63241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63242       };
63243     } catch (std::exception& e) {
63244       {
63245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63246       };
63247     } catch (...) {
63248       {
63249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63250       };
63251     }
63252   }
63253   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63254   return jresult;
63255 }
63256
63257
63258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
63259   void * jresult ;
63260   Dali::Toolkit::ScrollBar result;
63261
63262   {
63263     try {
63264       result = Dali::Toolkit::ScrollBar::New();
63265     } catch (std::out_of_range& e) {
63266       {
63267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63268       };
63269     } catch (std::exception& e) {
63270       {
63271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63272       };
63273     } catch (...) {
63274       {
63275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63276       };
63277     }
63278   }
63279   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63280   return jresult;
63281 }
63282
63283
63284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
63285   void * jresult ;
63286   Dali::BaseHandle arg1 ;
63287   Dali::BaseHandle *argp1 ;
63288   Dali::Toolkit::ScrollBar result;
63289
63290   argp1 = (Dali::BaseHandle *)jarg1;
63291   if (!argp1) {
63292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63293     return 0;
63294   }
63295   arg1 = *argp1;
63296   {
63297     try {
63298       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
63299     } catch (std::out_of_range& e) {
63300       {
63301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63302       };
63303     } catch (std::exception& e) {
63304       {
63305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63306       };
63307     } catch (...) {
63308       {
63309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63310       };
63311     }
63312   }
63313   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
63314   return jresult;
63315 }
63316
63317
63318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
63319   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63320   Dali::Handle arg2 ;
63321   Dali::Property::Index arg3 ;
63322   Dali::Property::Index arg4 ;
63323   Dali::Property::Index arg5 ;
63324   Dali::Property::Index arg6 ;
63325   Dali::Handle *argp2 ;
63326
63327   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63328   argp2 = (Dali::Handle *)jarg2;
63329   if (!argp2) {
63330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
63331     return ;
63332   }
63333   arg2 = *argp2;
63334   arg3 = (Dali::Property::Index)jarg3;
63335   arg4 = (Dali::Property::Index)jarg4;
63336   arg5 = (Dali::Property::Index)jarg5;
63337   arg6 = (Dali::Property::Index)jarg6;
63338   {
63339     try {
63340       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
63341     } catch (std::out_of_range& e) {
63342       {
63343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63344       };
63345     } catch (std::exception& e) {
63346       {
63347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63348       };
63349     } catch (...) {
63350       {
63351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63352       };
63353     }
63354   }
63355 }
63356
63357
63358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
63359   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63360   Dali::Actor arg2 ;
63361   Dali::Actor *argp2 ;
63362
63363   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63364   argp2 = (Dali::Actor *)jarg2;
63365   if (!argp2) {
63366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63367     return ;
63368   }
63369   arg2 = *argp2;
63370   {
63371     try {
63372       (arg1)->SetScrollIndicator(arg2);
63373     } catch (std::out_of_range& e) {
63374       {
63375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63376       };
63377     } catch (std::exception& e) {
63378       {
63379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63380       };
63381     } catch (...) {
63382       {
63383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63384       };
63385     }
63386   }
63387 }
63388
63389
63390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
63391   void * jresult ;
63392   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63393   Dali::Actor result;
63394
63395   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63396   {
63397     try {
63398       result = (arg1)->GetScrollIndicator();
63399     } catch (std::out_of_range& e) {
63400       {
63401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (std::exception& e) {
63404       {
63405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (...) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63410       };
63411     }
63412   }
63413   jresult = new Dali::Actor((const Dali::Actor &)result);
63414   return jresult;
63415 }
63416
63417
63418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
63419   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63420   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
63421
63422   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63423   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
63424   if (!arg2) {
63425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
63426     return ;
63427   }
63428   {
63429     try {
63430       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
63431     } catch (std::out_of_range& e) {
63432       {
63433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63434       };
63435     } catch (std::exception& e) {
63436       {
63437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63438       };
63439     } catch (...) {
63440       {
63441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63442       };
63443     }
63444   }
63445 }
63446
63447
63448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
63449   void * jresult ;
63450   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63451   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
63452
63453   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63454   {
63455     try {
63456       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
63457     } catch (std::out_of_range& e) {
63458       {
63459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63460       };
63461     } catch (std::exception& e) {
63462       {
63463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63464       };
63465     } catch (...) {
63466       {
63467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63468       };
63469     }
63470   }
63471   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
63472   return jresult;
63473 }
63474
63475
63476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
63477   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63478   Dali::Toolkit::ScrollBar::Direction arg2 ;
63479
63480   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63481   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
63482   {
63483     try {
63484       (arg1)->SetScrollDirection(arg2);
63485     } catch (std::out_of_range& e) {
63486       {
63487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63488       };
63489     } catch (std::exception& e) {
63490       {
63491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63496       };
63497     }
63498   }
63499 }
63500
63501
63502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
63503   int jresult ;
63504   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63505   Dali::Toolkit::ScrollBar::Direction result;
63506
63507   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63508   {
63509     try {
63510       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
63511     } catch (std::out_of_range& e) {
63512       {
63513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63514       };
63515     } catch (std::exception& e) {
63516       {
63517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63518       };
63519     } catch (...) {
63520       {
63521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63522       };
63523     }
63524   }
63525   jresult = (int)result;
63526   return jresult;
63527 }
63528
63529
63530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
63531   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63532   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
63533
63534   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63535   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
63536   {
63537     try {
63538       (arg1)->SetIndicatorHeightPolicy(arg2);
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63546       };
63547     } catch (...) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63550       };
63551     }
63552   }
63553 }
63554
63555
63556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
63557   int jresult ;
63558   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63559   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
63560
63561   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63562   {
63563     try {
63564       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
63565     } catch (std::out_of_range& e) {
63566       {
63567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63568       };
63569     } catch (std::exception& e) {
63570       {
63571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63572       };
63573     } catch (...) {
63574       {
63575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63576       };
63577     }
63578   }
63579   jresult = (int)result;
63580   return jresult;
63581 }
63582
63583
63584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
63585   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63586   float arg2 ;
63587
63588   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63589   arg2 = (float)jarg2;
63590   {
63591     try {
63592       (arg1)->SetIndicatorFixedHeight(arg2);
63593     } catch (std::out_of_range& e) {
63594       {
63595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63596       };
63597     } catch (std::exception& e) {
63598       {
63599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63600       };
63601     } catch (...) {
63602       {
63603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63604       };
63605     }
63606   }
63607 }
63608
63609
63610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
63611   float jresult ;
63612   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63613   float result;
63614
63615   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63616   {
63617     try {
63618       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
63619     } catch (std::out_of_range& e) {
63620       {
63621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63622       };
63623     } catch (std::exception& e) {
63624       {
63625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63630       };
63631     }
63632   }
63633   jresult = result;
63634   return jresult;
63635 }
63636
63637
63638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
63639   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63640   float arg2 ;
63641
63642   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63643   arg2 = (float)jarg2;
63644   {
63645     try {
63646       (arg1)->SetIndicatorShowDuration(arg2);
63647     } catch (std::out_of_range& e) {
63648       {
63649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63650       };
63651     } catch (std::exception& e) {
63652       {
63653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63654       };
63655     } catch (...) {
63656       {
63657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63658       };
63659     }
63660   }
63661 }
63662
63663
63664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
63665   float jresult ;
63666   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63667   float result;
63668
63669   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63670   {
63671     try {
63672       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
63673     } catch (std::out_of_range& e) {
63674       {
63675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63676       };
63677     } catch (std::exception& e) {
63678       {
63679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63680       };
63681     } catch (...) {
63682       {
63683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63684       };
63685     }
63686   }
63687   jresult = result;
63688   return jresult;
63689 }
63690
63691
63692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
63693   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63694   float arg2 ;
63695
63696   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63697   arg2 = (float)jarg2;
63698   {
63699     try {
63700       (arg1)->SetIndicatorHideDuration(arg2);
63701     } catch (std::out_of_range& e) {
63702       {
63703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63704       };
63705     } catch (std::exception& e) {
63706       {
63707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63708       };
63709     } catch (...) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63712       };
63713     }
63714   }
63715 }
63716
63717
63718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
63719   float jresult ;
63720   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63721   float result;
63722
63723   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63724   {
63725     try {
63726       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
63727     } catch (std::out_of_range& e) {
63728       {
63729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63730       };
63731     } catch (std::exception& e) {
63732       {
63733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63734       };
63735     } catch (...) {
63736       {
63737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63738       };
63739     }
63740   }
63741   jresult = result;
63742   return jresult;
63743 }
63744
63745
63746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
63747   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63748
63749   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63750   {
63751     try {
63752       (arg1)->ShowIndicator();
63753     } catch (std::out_of_range& e) {
63754       {
63755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63756       };
63757     } catch (std::exception& e) {
63758       {
63759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63760       };
63761     } catch (...) {
63762       {
63763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63764       };
63765     }
63766   }
63767 }
63768
63769
63770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
63771   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63772
63773   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63774   {
63775     try {
63776       (arg1)->HideIndicator();
63777     } catch (std::out_of_range& e) {
63778       {
63779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63780       };
63781     } catch (std::exception& e) {
63782       {
63783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63784       };
63785     } catch (...) {
63786       {
63787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63788       };
63789     }
63790   }
63791 }
63792
63793
63794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
63795   void * jresult ;
63796   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63797   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
63798
63799   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63800   {
63801     try {
63802       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
63803     } catch (std::out_of_range& e) {
63804       {
63805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63806       };
63807     } catch (std::exception& e) {
63808       {
63809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63810       };
63811     } catch (...) {
63812       {
63813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63814       };
63815     }
63816   }
63817   jresult = (void *)result;
63818   return jresult;
63819 }
63820
63821
63822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
63823   void * jresult ;
63824   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
63825   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
63826
63827   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
63828   {
63829     try {
63830       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
63831     } catch (std::out_of_range& e) {
63832       {
63833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63834       };
63835     } catch (std::exception& e) {
63836       {
63837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63838       };
63839     } catch (...) {
63840       {
63841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63842       };
63843     }
63844   }
63845   jresult = (void *)result;
63846   return jresult;
63847 }
63848
63849
63850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
63851   int jresult ;
63852   int result;
63853
63854   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
63855   jresult = (int)result;
63856   return jresult;
63857 }
63858
63859
63860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
63861   int jresult ;
63862   int result;
63863
63864   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
63865   jresult = (int)result;
63866   return jresult;
63867 }
63868
63869
63870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
63871   int jresult ;
63872   int result;
63873
63874   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
63875   jresult = (int)result;
63876   return jresult;
63877 }
63878
63879
63880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
63881   int jresult ;
63882   int result;
63883
63884   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
63885   jresult = (int)result;
63886   return jresult;
63887 }
63888
63889
63890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
63891   int jresult ;
63892   int result;
63893
63894   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
63895   jresult = (int)result;
63896   return jresult;
63897 }
63898
63899
63900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
63901   int jresult ;
63902   int result;
63903
63904   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
63905   jresult = (int)result;
63906   return jresult;
63907 }
63908
63909
63910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
63911   int jresult ;
63912   int result;
63913
63914   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
63915   jresult = (int)result;
63916   return jresult;
63917 }
63918
63919
63920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
63921   int jresult ;
63922   int result;
63923
63924   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
63925   jresult = (int)result;
63926   return jresult;
63927 }
63928
63929
63930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
63931   int jresult ;
63932   int result;
63933
63934   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
63935   jresult = (int)result;
63936   return jresult;
63937 }
63938
63939
63940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
63941   int jresult ;
63942   int result;
63943
63944   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
63945   jresult = (int)result;
63946   return jresult;
63947 }
63948
63949
63950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
63951   int jresult ;
63952   int result;
63953
63954   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
63955   jresult = (int)result;
63956   return jresult;
63957 }
63958
63959
63960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
63961   int jresult ;
63962   int result;
63963
63964   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
63965   jresult = (int)result;
63966   return jresult;
63967 }
63968
63969
63970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
63971   int jresult ;
63972   int result;
63973
63974   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
63975   jresult = (int)result;
63976   return jresult;
63977 }
63978
63979
63980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
63981   int jresult ;
63982   int result;
63983
63984   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
63985   jresult = (int)result;
63986   return jresult;
63987 }
63988
63989
63990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
63991   void * jresult ;
63992   Dali::Toolkit::Scrollable::Property *result = 0 ;
63993
63994   {
63995     try {
63996       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
63997     } catch (std::out_of_range& e) {
63998       {
63999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64000       };
64001     } catch (std::exception& e) {
64002       {
64003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64004       };
64005     } catch (...) {
64006       {
64007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64008       };
64009     }
64010   }
64011   jresult = (void *)result;
64012   return jresult;
64013 }
64014
64015
64016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
64017   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
64018
64019   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
64020   {
64021     try {
64022       delete arg1;
64023     } catch (std::out_of_range& e) {
64024       {
64025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64026       };
64027     } catch (std::exception& e) {
64028       {
64029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (...) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64034       };
64035     }
64036   }
64037 }
64038
64039
64040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
64041   void * jresult ;
64042   Dali::Toolkit::Scrollable *result = 0 ;
64043
64044   {
64045     try {
64046       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
64047     } catch (std::out_of_range& e) {
64048       {
64049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64050       };
64051     } catch (std::exception& e) {
64052       {
64053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64054       };
64055     } catch (...) {
64056       {
64057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64058       };
64059     }
64060   }
64061   jresult = (void *)result;
64062   return jresult;
64063 }
64064
64065
64066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
64067   void * jresult ;
64068   Dali::Toolkit::Scrollable *arg1 = 0 ;
64069   Dali::Toolkit::Scrollable *result = 0 ;
64070
64071   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64072   if (!arg1) {
64073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
64074     return 0;
64075   }
64076   {
64077     try {
64078       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
64079     } catch (std::out_of_range& e) {
64080       {
64081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64082       };
64083     } catch (std::exception& e) {
64084       {
64085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64086       };
64087     } catch (...) {
64088       {
64089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64090       };
64091     }
64092   }
64093   jresult = (void *)result;
64094   return jresult;
64095 }
64096
64097
64098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
64099   void * jresult ;
64100   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64101   Dali::Toolkit::Scrollable *arg2 = 0 ;
64102   Dali::Toolkit::Scrollable *result = 0 ;
64103
64104   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64105   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
64106   if (!arg2) {
64107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
64108     return 0;
64109   }
64110   {
64111     try {
64112       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
64113     } catch (std::out_of_range& e) {
64114       {
64115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64116       };
64117     } catch (std::exception& e) {
64118       {
64119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64120       };
64121     } catch (...) {
64122       {
64123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64124       };
64125     }
64126   }
64127   jresult = (void *)result;
64128   return jresult;
64129 }
64130
64131
64132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
64133   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64134
64135   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64136   {
64137     try {
64138       delete arg1;
64139     } catch (std::out_of_range& e) {
64140       {
64141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64142       };
64143     } catch (std::exception& e) {
64144       {
64145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64146       };
64147     } catch (...) {
64148       {
64149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64150       };
64151     }
64152   }
64153 }
64154
64155
64156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
64157   void * jresult ;
64158   Dali::BaseHandle arg1 ;
64159   Dali::BaseHandle *argp1 ;
64160   Dali::Toolkit::Scrollable result;
64161
64162   argp1 = (Dali::BaseHandle *)jarg1;
64163   if (!argp1) {
64164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64165     return 0;
64166   }
64167   arg1 = *argp1;
64168   {
64169     try {
64170       result = Dali::Toolkit::Scrollable::DownCast(arg1);
64171     } catch (std::out_of_range& e) {
64172       {
64173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64174       };
64175     } catch (std::exception& e) {
64176       {
64177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64178       };
64179     } catch (...) {
64180       {
64181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64182       };
64183     }
64184   }
64185   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
64186   return jresult;
64187 }
64188
64189
64190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
64191   unsigned int jresult ;
64192   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64193   bool result;
64194
64195   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64196   {
64197     try {
64198       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
64199     } catch (std::out_of_range& e) {
64200       {
64201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (std::exception& e) {
64204       {
64205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64206       };
64207     } catch (...) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64210       };
64211     }
64212   }
64213   jresult = result;
64214   return jresult;
64215 }
64216
64217
64218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
64219   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64220   bool arg2 ;
64221
64222   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64223   arg2 = jarg2 ? true : false;
64224   {
64225     try {
64226       (arg1)->SetOvershootEnabled(arg2);
64227     } catch (std::out_of_range& e) {
64228       {
64229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64230       };
64231     } catch (std::exception& e) {
64232       {
64233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64234       };
64235     } catch (...) {
64236       {
64237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64238       };
64239     }
64240   }
64241 }
64242
64243
64244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
64245   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64246   Dali::Vector4 *arg2 = 0 ;
64247
64248   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64249   arg2 = (Dali::Vector4 *)jarg2;
64250   if (!arg2) {
64251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
64252     return ;
64253   }
64254   {
64255     try {
64256       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
64257     } catch (std::out_of_range& e) {
64258       {
64259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64260       };
64261     } catch (std::exception& e) {
64262       {
64263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64264       };
64265     } catch (...) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64268       };
64269     }
64270   }
64271 }
64272
64273
64274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
64275   void * jresult ;
64276   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64277   Dali::Vector4 result;
64278
64279   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64280   {
64281     try {
64282       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
64283     } catch (std::out_of_range& e) {
64284       {
64285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64286       };
64287     } catch (std::exception& e) {
64288       {
64289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64290       };
64291     } catch (...) {
64292       {
64293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64294       };
64295     }
64296   }
64297   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64298   return jresult;
64299 }
64300
64301
64302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
64303   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64304   float arg2 ;
64305
64306   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64307   arg2 = (float)jarg2;
64308   {
64309     try {
64310       (arg1)->SetOvershootAnimationSpeed(arg2);
64311     } catch (std::out_of_range& e) {
64312       {
64313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64314       };
64315     } catch (std::exception& e) {
64316       {
64317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64318       };
64319     } catch (...) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64322       };
64323     }
64324   }
64325 }
64326
64327
64328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
64329   float jresult ;
64330   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64331   float result;
64332
64333   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64334   {
64335     try {
64336       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
64337     } catch (std::out_of_range& e) {
64338       {
64339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64340       };
64341     } catch (std::exception& e) {
64342       {
64343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64344       };
64345     } catch (...) {
64346       {
64347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64348       };
64349     }
64350   }
64351   jresult = result;
64352   return jresult;
64353 }
64354
64355
64356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
64357   void * jresult ;
64358   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64359   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
64360
64361   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64362   {
64363     try {
64364       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
64365     } catch (std::out_of_range& e) {
64366       {
64367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64368       };
64369     } catch (std::exception& e) {
64370       {
64371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64372       };
64373     } catch (...) {
64374       {
64375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64376       };
64377     }
64378   }
64379   jresult = (void *)result;
64380   return jresult;
64381 }
64382
64383
64384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
64385   void * jresult ;
64386   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64387   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
64388
64389   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64390   {
64391     try {
64392       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
64393     } catch (std::out_of_range& e) {
64394       {
64395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64396       };
64397     } catch (std::exception& e) {
64398       {
64399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64400       };
64401     } catch (...) {
64402       {
64403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64404       };
64405     }
64406   }
64407   jresult = (void *)result;
64408   return jresult;
64409 }
64410
64411
64412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
64413   void * jresult ;
64414   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
64415   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
64416
64417   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
64418   {
64419     try {
64420       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
64421     } catch (std::out_of_range& e) {
64422       {
64423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64424       };
64425     } catch (std::exception& e) {
64426       {
64427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64428       };
64429     } catch (...) {
64430       {
64431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64432       };
64433     }
64434   }
64435   jresult = (void *)result;
64436   return jresult;
64437 }
64438
64439
64440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
64441   unsigned int jresult ;
64442   Dali::Toolkit::ControlOrientation::Type arg1 ;
64443   bool result;
64444
64445   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64446   {
64447     try {
64448       result = (bool)Dali::Toolkit::IsVertical(arg1);
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 = result;
64464   return jresult;
64465 }
64466
64467
64468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
64469   unsigned int jresult ;
64470   Dali::Toolkit::ControlOrientation::Type arg1 ;
64471   bool result;
64472
64473   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
64474   {
64475     try {
64476       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
64477     } catch (std::out_of_range& e) {
64478       {
64479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64480       };
64481     } catch (std::exception& e) {
64482       {
64483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64484       };
64485     } catch (...) {
64486       {
64487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64488       };
64489     }
64490   }
64491   jresult = result;
64492   return jresult;
64493 }
64494
64495
64496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
64497   void * jresult ;
64498   unsigned int arg1 ;
64499   unsigned int arg2 ;
64500   Dali::Toolkit::ItemRange *result = 0 ;
64501
64502   arg1 = (unsigned int)jarg1;
64503   arg2 = (unsigned int)jarg2;
64504   {
64505     try {
64506       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
64507     } catch (std::out_of_range& e) {
64508       {
64509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64510       };
64511     } catch (std::exception& e) {
64512       {
64513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64514       };
64515     } catch (...) {
64516       {
64517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64518       };
64519     }
64520   }
64521   jresult = (void *)result;
64522   return jresult;
64523 }
64524
64525
64526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
64527   void * jresult ;
64528   Dali::Toolkit::ItemRange *arg1 = 0 ;
64529   Dali::Toolkit::ItemRange *result = 0 ;
64530
64531   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64532   if (!arg1) {
64533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64534     return 0;
64535   }
64536   {
64537     try {
64538       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
64539     } catch (std::out_of_range& e) {
64540       {
64541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64542       };
64543     } catch (std::exception& e) {
64544       {
64545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64546       };
64547     } catch (...) {
64548       {
64549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64550       };
64551     }
64552   }
64553   jresult = (void *)result;
64554   return jresult;
64555 }
64556
64557
64558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
64559   void * jresult ;
64560   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64561   Dali::Toolkit::ItemRange *arg2 = 0 ;
64562   Dali::Toolkit::ItemRange *result = 0 ;
64563
64564   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64565   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64566   if (!arg2) {
64567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64568     return 0;
64569   }
64570   {
64571     try {
64572       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
64573     } catch (std::out_of_range& e) {
64574       {
64575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64576       };
64577     } catch (std::exception& e) {
64578       {
64579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64580       };
64581     } catch (...) {
64582       {
64583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64584       };
64585     }
64586   }
64587   jresult = (void *)result;
64588   return jresult;
64589 }
64590
64591
64592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
64593   unsigned int jresult ;
64594   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64595   unsigned int arg2 ;
64596   bool result;
64597
64598   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64599   arg2 = (unsigned int)jarg2;
64600   {
64601     try {
64602       result = (bool)(arg1)->Within(arg2);
64603     } catch (std::out_of_range& e) {
64604       {
64605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (std::exception& e) {
64608       {
64609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64610       };
64611     } catch (...) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64614       };
64615     }
64616   }
64617   jresult = result;
64618   return jresult;
64619 }
64620
64621
64622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
64623   void * jresult ;
64624   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64625   Dali::Toolkit::ItemRange *arg2 = 0 ;
64626   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
64627
64628   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64629   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
64630   if (!arg2) {
64631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
64632     return 0;
64633   }
64634   {
64635     try {
64636       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
64637     } catch (std::out_of_range& e) {
64638       {
64639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64640       };
64641     } catch (std::exception& e) {
64642       {
64643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64644       };
64645     } catch (...) {
64646       {
64647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64648       };
64649     }
64650   }
64651   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
64652   return jresult;
64653 }
64654
64655
64656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
64657   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64658   unsigned int arg2 ;
64659
64660   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64661   arg2 = (unsigned int)jarg2;
64662   if (arg1) (arg1)->begin = arg2;
64663 }
64664
64665
64666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
64667   unsigned int jresult ;
64668   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64669   unsigned int result;
64670
64671   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64672   result = (unsigned int) ((arg1)->begin);
64673   jresult = result;
64674   return jresult;
64675 }
64676
64677
64678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
64679   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64680   unsigned int arg2 ;
64681
64682   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64683   arg2 = (unsigned int)jarg2;
64684   if (arg1) (arg1)->end = arg2;
64685 }
64686
64687
64688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
64689   unsigned int jresult ;
64690   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64691   unsigned int result;
64692
64693   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64694   result = (unsigned int) ((arg1)->end);
64695   jresult = result;
64696   return jresult;
64697 }
64698
64699
64700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
64701   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
64702
64703   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
64704   {
64705     try {
64706       delete arg1;
64707     } catch (std::out_of_range& e) {
64708       {
64709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64710       };
64711     } catch (std::exception& e) {
64712       {
64713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64714       };
64715     } catch (...) {
64716       {
64717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64718       };
64719     }
64720   }
64721 }
64722
64723
64724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
64725   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64726
64727   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64728   {
64729     try {
64730       delete arg1;
64731     } catch (std::out_of_range& e) {
64732       {
64733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64734       };
64735     } catch (std::exception& e) {
64736       {
64737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64738       };
64739     } catch (...) {
64740       {
64741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64742       };
64743     }
64744   }
64745 }
64746
64747
64748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
64749   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64750   Dali::Toolkit::ControlOrientation::Type arg2 ;
64751
64752   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64753   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
64754   {
64755     try {
64756       (arg1)->SetOrientation(arg2);
64757     } catch (std::out_of_range& e) {
64758       {
64759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64760       };
64761     } catch (std::exception& e) {
64762       {
64763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64764       };
64765     } catch (...) {
64766       {
64767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64768       };
64769     }
64770   }
64771 }
64772
64773
64774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
64775   int jresult ;
64776   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64777   Dali::Toolkit::ControlOrientation::Type result;
64778
64779   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64780   {
64781     try {
64782       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
64783     } catch (std::out_of_range& e) {
64784       {
64785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64786       };
64787     } catch (std::exception& e) {
64788       {
64789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64790       };
64791     } catch (...) {
64792       {
64793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64794       };
64795     }
64796   }
64797   jresult = (int)result;
64798   return jresult;
64799 }
64800
64801
64802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
64803   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64804   Dali::Property::Map *arg2 = 0 ;
64805
64806   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64807   arg2 = (Dali::Property::Map *)jarg2;
64808   if (!arg2) {
64809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
64810     return ;
64811   }
64812   {
64813     try {
64814       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
64815     } catch (std::out_of_range& e) {
64816       {
64817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64818       };
64819     } catch (std::exception& e) {
64820       {
64821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64822       };
64823     } catch (...) {
64824       {
64825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64826       };
64827     }
64828   }
64829 }
64830
64831
64832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
64833   void * jresult ;
64834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64835   Dali::Property::Map result;
64836
64837   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64838   {
64839     try {
64840       result = (arg1)->GetLayoutProperties();
64841     } catch (std::out_of_range& e) {
64842       {
64843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64844       };
64845     } catch (std::exception& e) {
64846       {
64847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64848       };
64849     } catch (...) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64852       };
64853     }
64854   }
64855   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
64856   return jresult;
64857 }
64858
64859
64860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
64861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64862   unsigned int arg2 ;
64863   Dali::Vector3 *arg3 = 0 ;
64864   Dali::Vector3 *arg4 = 0 ;
64865
64866   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64867   arg2 = (unsigned int)jarg2;
64868   arg3 = (Dali::Vector3 *)jarg3;
64869   if (!arg3) {
64870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64871     return ;
64872   }
64873   arg4 = (Dali::Vector3 *)jarg4;
64874   if (!arg4) {
64875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
64876     return ;
64877   }
64878   {
64879     try {
64880       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
64881     } catch (std::out_of_range& e) {
64882       {
64883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64884       };
64885     } catch (std::exception& e) {
64886       {
64887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64888       };
64889     } catch (...) {
64890       {
64891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64892       };
64893     }
64894   }
64895 }
64896
64897
64898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
64899   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64900   Dali::Vector3 *arg2 = 0 ;
64901
64902   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64903   arg2 = (Dali::Vector3 *)jarg2;
64904   if (!arg2) {
64905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64906     return ;
64907   }
64908   {
64909     try {
64910       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
64911     } catch (std::out_of_range& e) {
64912       {
64913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64914       };
64915     } catch (std::exception& e) {
64916       {
64917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64918       };
64919     } catch (...) {
64920       {
64921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64922       };
64923     }
64924   }
64925 }
64926
64927
64928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
64929   float jresult ;
64930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64931   unsigned int arg2 ;
64932   Dali::Vector3 arg3 ;
64933   Dali::Vector3 *argp3 ;
64934   float result;
64935
64936   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64937   arg2 = (unsigned int)jarg2;
64938   argp3 = (Dali::Vector3 *)jarg3;
64939   if (!argp3) {
64940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
64941     return 0;
64942   }
64943   arg3 = *argp3;
64944   {
64945     try {
64946       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
64947     } catch (std::out_of_range& e) {
64948       {
64949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64950       };
64951     } catch (std::exception& e) {
64952       {
64953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64954       };
64955     } catch (...) {
64956       {
64957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64958       };
64959     }
64960   }
64961   jresult = result;
64962   return jresult;
64963 }
64964
64965
64966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
64967   float jresult ;
64968   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64969   float arg2 ;
64970   float result;
64971
64972   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
64973   arg2 = (float)jarg2;
64974   {
64975     try {
64976       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
64977     } catch (std::out_of_range& e) {
64978       {
64979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64980       };
64981     } catch (std::exception& e) {
64982       {
64983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (...) {
64986       {
64987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64988       };
64989     }
64990   }
64991   jresult = result;
64992   return jresult;
64993 }
64994
64995
64996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
64997   float jresult ;
64998   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
64999   unsigned int arg2 ;
65000   float result;
65001
65002   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65003   arg2 = (unsigned int)jarg2;
65004   {
65005     try {
65006       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
65007     } catch (std::out_of_range& e) {
65008       {
65009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (std::exception& e) {
65012       {
65013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65018       };
65019     }
65020   }
65021   jresult = result;
65022   return jresult;
65023 }
65024
65025
65026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
65027   void * jresult ;
65028   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65029   float arg2 ;
65030   Dali::Vector3 arg3 ;
65031   Dali::Vector3 *argp3 ;
65032   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
65033
65034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65035   arg2 = (float)jarg2;
65036   argp3 = (Dali::Vector3 *)jarg3;
65037   if (!argp3) {
65038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65039     return 0;
65040   }
65041   arg3 = *argp3;
65042   {
65043     try {
65044       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
65045     } catch (std::out_of_range& e) {
65046       {
65047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (std::exception& e) {
65050       {
65051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65052       };
65053     } catch (...) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65056       };
65057     }
65058   }
65059   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65065   float jresult ;
65066   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65067   int arg2 ;
65068   float arg3 ;
65069   Dali::Vector3 *arg4 = 0 ;
65070   float result;
65071
65072   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65073   arg2 = (int)jarg2;
65074   arg3 = (float)jarg3;
65075   arg4 = (Dali::Vector3 *)jarg4;
65076   if (!arg4) {
65077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65078     return 0;
65079   }
65080   {
65081     try {
65082       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65083     } catch (std::out_of_range& e) {
65084       {
65085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65086       };
65087     } catch (std::exception& e) {
65088       {
65089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65090       };
65091     } catch (...) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65094       };
65095     }
65096   }
65097   jresult = result;
65098   return jresult;
65099 }
65100
65101
65102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
65103   unsigned int jresult ;
65104   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65105   Dali::Vector3 arg2 ;
65106   Dali::Vector3 *argp2 ;
65107   unsigned int result;
65108
65109   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65110   argp2 = (Dali::Vector3 *)jarg2;
65111   if (!argp2) {
65112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
65113     return 0;
65114   }
65115   arg2 = *argp2;
65116   {
65117     try {
65118       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
65119     } catch (std::out_of_range& e) {
65120       {
65121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65122       };
65123     } catch (std::exception& e) {
65124       {
65125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65126       };
65127     } catch (...) {
65128       {
65129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65130       };
65131     }
65132   }
65133   jresult = result;
65134   return jresult;
65135 }
65136
65137
65138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
65139   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65140   unsigned int arg2 ;
65141   Dali::Vector3 *arg3 = 0 ;
65142   Dali::Vector3 *arg4 = 0 ;
65143
65144   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65145   arg2 = (unsigned int)jarg2;
65146   arg3 = (Dali::Vector3 *)jarg3;
65147   if (!arg3) {
65148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65149     return ;
65150   }
65151   arg4 = (Dali::Vector3 *)jarg4;
65152   if (!arg4) {
65153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
65154     return ;
65155   }
65156   {
65157     try {
65158       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
65159     } catch (std::out_of_range& e) {
65160       {
65161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65162       };
65163     } catch (std::exception& e) {
65164       {
65165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65170       };
65171     }
65172   }
65173 }
65174
65175
65176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
65177   void * jresult ;
65178   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65179   Dali::Degree result;
65180
65181   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65182   {
65183     try {
65184       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
65185     } catch (std::out_of_range& e) {
65186       {
65187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65188       };
65189     } catch (std::exception& e) {
65190       {
65191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65192       };
65193     } catch (...) {
65194       {
65195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65196       };
65197     }
65198   }
65199   jresult = new Dali::Degree((const Dali::Degree &)result);
65200   return jresult;
65201 }
65202
65203
65204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
65205   float jresult ;
65206   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65207   float result;
65208
65209   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65210   {
65211     try {
65212       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
65213     } catch (std::out_of_range& e) {
65214       {
65215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65216       };
65217     } catch (std::exception& e) {
65218       {
65219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65220       };
65221     } catch (...) {
65222       {
65223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65224       };
65225     }
65226   }
65227   jresult = result;
65228   return jresult;
65229 }
65230
65231
65232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
65233   float jresult ;
65234   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65235   float result;
65236
65237   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65238   {
65239     try {
65240       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
65241     } catch (std::out_of_range& e) {
65242       {
65243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65244       };
65245     } catch (std::exception& e) {
65246       {
65247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65248       };
65249     } catch (...) {
65250       {
65251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65252       };
65253     }
65254   }
65255   jresult = result;
65256   return jresult;
65257 }
65258
65259
65260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
65261   float jresult ;
65262   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65263   float result;
65264
65265   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65266   {
65267     try {
65268       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
65269     } catch (std::out_of_range& e) {
65270       {
65271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65272       };
65273     } catch (std::exception& e) {
65274       {
65275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65276       };
65277     } catch (...) {
65278       {
65279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65280       };
65281     }
65282   }
65283   jresult = result;
65284   return jresult;
65285 }
65286
65287
65288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
65289   int jresult ;
65290   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65291   int arg2 ;
65292   int arg3 ;
65293   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
65294   bool arg5 ;
65295   int result;
65296
65297   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65298   arg2 = (int)jarg2;
65299   arg3 = (int)jarg3;
65300   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
65301   arg5 = jarg5 ? true : false;
65302   {
65303     try {
65304       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
65305     } catch (std::out_of_range& e) {
65306       {
65307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65308       };
65309     } catch (std::exception& e) {
65310       {
65311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65316       };
65317     }
65318   }
65319   jresult = result;
65320   return jresult;
65321 }
65322
65323
65324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
65325   float jresult ;
65326   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65327   float result;
65328
65329   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65330   {
65331     try {
65332       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
65333     } catch (std::out_of_range& e) {
65334       {
65335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65336       };
65337     } catch (std::exception& e) {
65338       {
65339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65340       };
65341     } catch (...) {
65342       {
65343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65344       };
65345     }
65346   }
65347   jresult = result;
65348   return jresult;
65349 }
65350
65351
65352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
65353   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65354   Dali::Actor *arg2 = 0 ;
65355   int arg3 ;
65356   Dali::Vector3 *arg4 = 0 ;
65357   Dali::Actor *arg5 = 0 ;
65358
65359   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65360   arg2 = (Dali::Actor *)jarg2;
65361   if (!arg2) {
65362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65363     return ;
65364   }
65365   arg3 = (int)jarg3;
65366   arg4 = (Dali::Vector3 *)jarg4;
65367   if (!arg4) {
65368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65369     return ;
65370   }
65371   arg5 = (Dali::Actor *)jarg5;
65372   if (!arg5) {
65373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65374     return ;
65375   }
65376   {
65377     try {
65378       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
65379     } catch (std::out_of_range& e) {
65380       {
65381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65382       };
65383     } catch (std::exception& e) {
65384       {
65385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65386       };
65387     } catch (...) {
65388       {
65389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65390       };
65391     }
65392   }
65393 }
65394
65395
65396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
65397   void * jresult ;
65398   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
65399   int arg2 ;
65400   float arg3 ;
65401   Dali::Vector3 *arg4 = 0 ;
65402   Dali::Vector3 result;
65403
65404   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
65405   arg2 = (int)jarg2;
65406   arg3 = (float)jarg3;
65407   arg4 = (Dali::Vector3 *)jarg4;
65408   if (!arg4) {
65409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
65410     return 0;
65411   }
65412   {
65413     try {
65414       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
65415     } catch (std::out_of_range& e) {
65416       {
65417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65418       };
65419     } catch (std::exception& e) {
65420       {
65421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65422       };
65423     } catch (...) {
65424       {
65425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65426       };
65427     }
65428   }
65429   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65430   return jresult;
65431 }
65432
65433
65434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
65435   void * jresult ;
65436   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
65437   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
65438
65439   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
65440   {
65441     try {
65442       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
65443     } catch (std::out_of_range& e) {
65444       {
65445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65446       };
65447     } catch (std::exception& e) {
65448       {
65449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65450       };
65451     } catch (...) {
65452       {
65453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65454       };
65455     }
65456   }
65457   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
65458   return jresult;
65459 }
65460
65461
65462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
65463   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65464
65465   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65466   {
65467     try {
65468       delete arg1;
65469     } catch (std::out_of_range& e) {
65470       {
65471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65472       };
65473     } catch (std::exception& e) {
65474       {
65475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65476       };
65477     } catch (...) {
65478       {
65479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65480       };
65481     }
65482   }
65483 }
65484
65485
65486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
65487   unsigned int jresult ;
65488   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65489   unsigned int result;
65490
65491   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65492   {
65493     try {
65494       result = (unsigned int)(arg1)->GetNumberOfItems();
65495     } catch (std::out_of_range& e) {
65496       {
65497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65498       };
65499     } catch (std::exception& e) {
65500       {
65501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65502       };
65503     } catch (...) {
65504       {
65505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65506       };
65507     }
65508   }
65509   jresult = result;
65510   return jresult;
65511 }
65512
65513
65514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
65515   void * jresult ;
65516   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65517   unsigned int arg2 ;
65518   Dali::Actor result;
65519
65520   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65521   arg2 = (unsigned int)jarg2;
65522   {
65523     try {
65524       result = (arg1)->NewItem(arg2);
65525     } catch (std::out_of_range& e) {
65526       {
65527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65528       };
65529     } catch (std::exception& e) {
65530       {
65531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65532       };
65533     } catch (...) {
65534       {
65535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65536       };
65537     }
65538   }
65539   jresult = new Dali::Actor((const Dali::Actor &)result);
65540   return jresult;
65541 }
65542
65543
65544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
65545   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65546   unsigned int arg2 ;
65547   Dali::Actor arg3 ;
65548   Dali::Actor *argp3 ;
65549
65550   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65551   arg2 = (unsigned int)jarg2;
65552   argp3 = (Dali::Actor *)jarg3;
65553   if (!argp3) {
65554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65555     return ;
65556   }
65557   arg3 = *argp3;
65558   {
65559     try {
65560       (arg1)->ItemReleased(arg2,arg3);
65561     } catch (std::out_of_range& e) {
65562       {
65563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65564       };
65565     } catch (std::exception& e) {
65566       {
65567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65568       };
65569     } catch (...) {
65570       {
65571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65572       };
65573     }
65574   }
65575 }
65576
65577
65578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
65579   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
65580   unsigned int arg2 ;
65581   Dali::Actor arg3 ;
65582   Dali::Actor *argp3 ;
65583
65584   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65585   arg2 = (unsigned int)jarg2;
65586   argp3 = (Dali::Actor *)jarg3;
65587   if (!argp3) {
65588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65589     return ;
65590   }
65591   arg3 = *argp3;
65592   {
65593     try {
65594       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
65595     } catch (std::out_of_range& e) {
65596       {
65597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65598       };
65599     } catch (std::exception& e) {
65600       {
65601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65602       };
65603     } catch (...) {
65604       {
65605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65606       };
65607     }
65608   }
65609 }
65610
65611
65612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
65613   void * jresult ;
65614   Dali::Toolkit::ItemFactory *result = 0 ;
65615
65616   {
65617     try {
65618       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
65619     } catch (std::out_of_range& e) {
65620       {
65621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65622       };
65623     } catch (std::exception& e) {
65624       {
65625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65626       };
65627     } catch (...) {
65628       {
65629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65630       };
65631     }
65632   }
65633   jresult = (void *)result;
65634   return jresult;
65635 }
65636
65637
65638 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) {
65639   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
65640   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
65641   if (director) {
65642     director->swig_connect_director(callback0, callback1, callback2);
65643   }
65644 }
65645
65646
65647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
65648   int jresult ;
65649   int result;
65650
65651   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
65652   jresult = (int)result;
65653   return jresult;
65654 }
65655
65656
65657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
65658   int jresult ;
65659   int result;
65660
65661   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
65662   jresult = (int)result;
65663   return jresult;
65664 }
65665
65666
65667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
65668   int jresult ;
65669   int result;
65670
65671   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
65672   jresult = (int)result;
65673   return jresult;
65674 }
65675
65676
65677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
65678   int jresult ;
65679   int result;
65680
65681   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
65682   jresult = (int)result;
65683   return jresult;
65684 }
65685
65686
65687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
65688   int jresult ;
65689   int result;
65690
65691   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
65692   jresult = (int)result;
65693   return jresult;
65694 }
65695
65696
65697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
65698   int jresult ;
65699   int result;
65700
65701   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
65702   jresult = (int)result;
65703   return jresult;
65704 }
65705
65706
65707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
65708   int jresult ;
65709   int result;
65710
65711   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
65712   jresult = (int)result;
65713   return jresult;
65714 }
65715
65716
65717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
65718   int jresult ;
65719   int result;
65720
65721   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
65722   jresult = (int)result;
65723   return jresult;
65724 }
65725
65726
65727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
65728   int jresult ;
65729   int result;
65730
65731   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
65732   jresult = (int)result;
65733   return jresult;
65734 }
65735
65736
65737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
65738   int jresult ;
65739   int result;
65740
65741   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
65742   jresult = (int)result;
65743   return jresult;
65744 }
65745
65746
65747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
65748   int jresult ;
65749   int result;
65750
65751   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
65752   jresult = (int)result;
65753   return jresult;
65754 }
65755
65756
65757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
65758   void * jresult ;
65759   Dali::Toolkit::ItemView::Property *result = 0 ;
65760
65761   {
65762     try {
65763       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
65764     } catch (std::out_of_range& e) {
65765       {
65766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65767       };
65768     } catch (std::exception& e) {
65769       {
65770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65771       };
65772     } catch (...) {
65773       {
65774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65775       };
65776     }
65777   }
65778   jresult = (void *)result;
65779   return jresult;
65780 }
65781
65782
65783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
65784   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
65785
65786   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
65787   {
65788     try {
65789       delete arg1;
65790     } catch (std::out_of_range& e) {
65791       {
65792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65793       };
65794     } catch (std::exception& e) {
65795       {
65796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65797       };
65798     } catch (...) {
65799       {
65800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65801       };
65802     }
65803   }
65804 }
65805
65806
65807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
65808   void * jresult ;
65809   Dali::Toolkit::ItemView *result = 0 ;
65810
65811   {
65812     try {
65813       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
65814     } catch (std::out_of_range& e) {
65815       {
65816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (std::exception& e) {
65819       {
65820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65821       };
65822     } catch (...) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65825       };
65826     }
65827   }
65828   jresult = (void *)result;
65829   return jresult;
65830 }
65831
65832
65833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
65834   void * jresult ;
65835   Dali::Toolkit::ItemView *arg1 = 0 ;
65836   Dali::Toolkit::ItemView *result = 0 ;
65837
65838   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65839   if (!arg1) {
65840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65841     return 0;
65842   }
65843   {
65844     try {
65845       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
65846     } catch (std::out_of_range& e) {
65847       {
65848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (std::exception& e) {
65851       {
65852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65853       };
65854     } catch (...) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65857       };
65858     }
65859   }
65860   jresult = (void *)result;
65861   return jresult;
65862 }
65863
65864
65865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
65866   void * jresult ;
65867   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65868   Dali::Toolkit::ItemView *arg2 = 0 ;
65869   Dali::Toolkit::ItemView *result = 0 ;
65870
65871   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65872   arg2 = (Dali::Toolkit::ItemView *)jarg2;
65873   if (!arg2) {
65874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
65875     return 0;
65876   }
65877   {
65878     try {
65879       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
65880     } catch (std::out_of_range& e) {
65881       {
65882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65883       };
65884     } catch (std::exception& e) {
65885       {
65886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65887       };
65888     } catch (...) {
65889       {
65890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65891       };
65892     }
65893   }
65894   jresult = (void *)result;
65895   return jresult;
65896 }
65897
65898
65899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
65900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65901
65902   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65903   {
65904     try {
65905       delete arg1;
65906     } catch (std::out_of_range& e) {
65907       {
65908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65909       };
65910     } catch (std::exception& e) {
65911       {
65912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65913       };
65914     } catch (...) {
65915       {
65916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65917       };
65918     }
65919   }
65920 }
65921
65922
65923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
65924   void * jresult ;
65925   Dali::Toolkit::ItemFactory *arg1 = 0 ;
65926   Dali::Toolkit::ItemView result;
65927
65928   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
65929   if (!arg1) {
65930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
65931     return 0;
65932   }
65933   {
65934     try {
65935       result = Dali::Toolkit::ItemView::New(*arg1);
65936     } catch (std::out_of_range& e) {
65937       {
65938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65939       };
65940     } catch (std::exception& e) {
65941       {
65942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65943       };
65944     } catch (...) {
65945       {
65946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65947       };
65948     }
65949   }
65950   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65951   return jresult;
65952 }
65953
65954
65955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
65956   void * jresult ;
65957   Dali::BaseHandle arg1 ;
65958   Dali::BaseHandle *argp1 ;
65959   Dali::Toolkit::ItemView result;
65960
65961   argp1 = (Dali::BaseHandle *)jarg1;
65962   if (!argp1) {
65963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65964     return 0;
65965   }
65966   arg1 = *argp1;
65967   {
65968     try {
65969       result = Dali::Toolkit::ItemView::DownCast(arg1);
65970     } catch (std::out_of_range& e) {
65971       {
65972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65973       };
65974     } catch (std::exception& e) {
65975       {
65976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65977       };
65978     } catch (...) {
65979       {
65980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65981       };
65982     }
65983   }
65984   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
65985   return jresult;
65986 }
65987
65988
65989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
65990   unsigned int jresult ;
65991   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
65992   unsigned int result;
65993
65994   arg1 = (Dali::Toolkit::ItemView *)jarg1;
65995   {
65996     try {
65997       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
65998     } catch (std::out_of_range& e) {
65999       {
66000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66001       };
66002     } catch (std::exception& e) {
66003       {
66004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66005       };
66006     } catch (...) {
66007       {
66008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66009       };
66010     }
66011   }
66012   jresult = result;
66013   return jresult;
66014 }
66015
66016
66017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
66018   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66019   Dali::Toolkit::ItemLayout *arg2 = 0 ;
66020
66021   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66022   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
66023   if (!arg2) {
66024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
66025     return ;
66026   }
66027   {
66028     try {
66029       (arg1)->AddLayout(*arg2);
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66037       };
66038     } catch (...) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66041       };
66042     }
66043   }
66044 }
66045
66046
66047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
66048   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66049   unsigned int arg2 ;
66050
66051   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66052   arg2 = (unsigned int)jarg2;
66053   {
66054     try {
66055       (arg1)->RemoveLayout(arg2);
66056     } catch (std::out_of_range& e) {
66057       {
66058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66059       };
66060     } catch (std::exception& e) {
66061       {
66062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66063       };
66064     } catch (...) {
66065       {
66066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66067       };
66068     }
66069   }
66070 }
66071
66072
66073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
66074   void * jresult ;
66075   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66076   unsigned int arg2 ;
66077   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
66078
66079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66080   arg2 = (unsigned int)jarg2;
66081   {
66082     try {
66083       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
66084     } catch (std::out_of_range& e) {
66085       {
66086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66087       };
66088     } catch (std::exception& e) {
66089       {
66090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66091       };
66092     } catch (...) {
66093       {
66094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66095       };
66096     }
66097   }
66098   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
66099   return jresult;
66100 }
66101
66102
66103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
66104   void * jresult ;
66105   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66106   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
66107
66108   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66109   {
66110     try {
66111       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
66112     } catch (std::out_of_range& e) {
66113       {
66114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (std::exception& e) {
66117       {
66118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66119       };
66120     } catch (...) {
66121       {
66122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66123       };
66124     }
66125   }
66126   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
66127   return jresult;
66128 }
66129
66130
66131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
66132   float jresult ;
66133   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66134   Dali::Toolkit::ItemId arg2 ;
66135   float result;
66136
66137   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66138   arg2 = (Dali::Toolkit::ItemId)jarg2;
66139   {
66140     try {
66141       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
66142     } catch (std::out_of_range& e) {
66143       {
66144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66145       };
66146     } catch (std::exception& e) {
66147       {
66148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66149       };
66150     } catch (...) {
66151       {
66152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66153       };
66154     }
66155   }
66156   jresult = result;
66157   return jresult;
66158 }
66159
66160
66161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
66162   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66163   unsigned int arg2 ;
66164   Dali::Vector3 arg3 ;
66165   float arg4 ;
66166   Dali::Vector3 *argp3 ;
66167
66168   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66169   arg2 = (unsigned int)jarg2;
66170   argp3 = (Dali::Vector3 *)jarg3;
66171   if (!argp3) {
66172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
66173     return ;
66174   }
66175   arg3 = *argp3;
66176   arg4 = (float)jarg4;
66177   {
66178     try {
66179       (arg1)->ActivateLayout(arg2,arg3,arg4);
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66187       };
66188     } catch (...) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66191       };
66192     }
66193   }
66194 }
66195
66196
66197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
66198   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66199
66200   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66201   {
66202     try {
66203       (arg1)->DeactivateCurrentLayout();
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 void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
66222   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66223   float arg2 ;
66224
66225   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66226   arg2 = (float)jarg2;
66227   {
66228     try {
66229       (arg1)->SetMinimumSwipeSpeed(arg2);
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66237       };
66238     } catch (...) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66241       };
66242     }
66243   }
66244 }
66245
66246
66247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
66248   float jresult ;
66249   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66250   float result;
66251
66252   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66253   {
66254     try {
66255       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
66256     } catch (std::out_of_range& e) {
66257       {
66258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66259       };
66260     } catch (std::exception& e) {
66261       {
66262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66267       };
66268     }
66269   }
66270   jresult = result;
66271   return jresult;
66272 }
66273
66274
66275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
66276   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66277   float arg2 ;
66278
66279   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66280   arg2 = (float)jarg2;
66281   {
66282     try {
66283       (arg1)->SetMinimumSwipeDistance(arg2);
66284     } catch (std::out_of_range& e) {
66285       {
66286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66287       };
66288     } catch (std::exception& e) {
66289       {
66290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66291       };
66292     } catch (...) {
66293       {
66294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66295       };
66296     }
66297   }
66298 }
66299
66300
66301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
66302   float jresult ;
66303   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66304   float result;
66305
66306   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66307   {
66308     try {
66309       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
66310     } catch (std::out_of_range& e) {
66311       {
66312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66313       };
66314     } catch (std::exception& e) {
66315       {
66316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66317       };
66318     } catch (...) {
66319       {
66320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66321       };
66322     }
66323   }
66324   jresult = result;
66325   return jresult;
66326 }
66327
66328
66329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
66330   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66331   float arg2 ;
66332
66333   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66334   arg2 = (float)jarg2;
66335   {
66336     try {
66337       (arg1)->SetWheelScrollDistanceStep(arg2);
66338     } catch (std::out_of_range& e) {
66339       {
66340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66341       };
66342     } catch (std::exception& e) {
66343       {
66344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66345       };
66346     } catch (...) {
66347       {
66348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66349       };
66350     }
66351   }
66352 }
66353
66354
66355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
66356   float jresult ;
66357   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66358   float result;
66359
66360   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66361   {
66362     try {
66363       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
66364     } catch (std::out_of_range& e) {
66365       {
66366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66367       };
66368     } catch (std::exception& e) {
66369       {
66370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66371       };
66372     } catch (...) {
66373       {
66374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66375       };
66376     }
66377   }
66378   jresult = result;
66379   return jresult;
66380 }
66381
66382
66383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
66384   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66385   bool arg2 ;
66386
66387   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66388   arg2 = jarg2 ? true : false;
66389   {
66390     try {
66391       (arg1)->SetAnchoring(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
66410   unsigned int jresult ;
66411   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66412   bool result;
66413
66414   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66415   {
66416     try {
66417       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (...) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66429       };
66430     }
66431   }
66432   jresult = result;
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
66438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66439   float arg2 ;
66440
66441   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66442   arg2 = (float)jarg2;
66443   {
66444     try {
66445       (arg1)->SetAnchoringDuration(arg2);
66446     } catch (std::out_of_range& e) {
66447       {
66448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66449       };
66450     } catch (std::exception& e) {
66451       {
66452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66453       };
66454     } catch (...) {
66455       {
66456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66457       };
66458     }
66459   }
66460 }
66461
66462
66463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
66464   float jresult ;
66465   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66466   float result;
66467
66468   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66469   {
66470     try {
66471       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
66472     } catch (std::out_of_range& e) {
66473       {
66474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66475       };
66476     } catch (std::exception& e) {
66477       {
66478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66479       };
66480     } catch (...) {
66481       {
66482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66483       };
66484     }
66485   }
66486   jresult = result;
66487   return jresult;
66488 }
66489
66490
66491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
66492   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66493   Dali::Toolkit::ItemId arg2 ;
66494   float arg3 ;
66495
66496   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66497   arg2 = (Dali::Toolkit::ItemId)jarg2;
66498   arg3 = (float)jarg3;
66499   {
66500     try {
66501       (arg1)->ScrollToItem(arg2,arg3);
66502     } catch (std::out_of_range& e) {
66503       {
66504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66505       };
66506     } catch (std::exception& e) {
66507       {
66508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66509       };
66510     } catch (...) {
66511       {
66512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66513       };
66514     }
66515   }
66516 }
66517
66518
66519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
66520   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66521   float arg2 ;
66522
66523   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66524   arg2 = (float)jarg2;
66525   {
66526     try {
66527       (arg1)->SetRefreshInterval(arg2);
66528     } catch (std::out_of_range& e) {
66529       {
66530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66531       };
66532     } catch (std::exception& e) {
66533       {
66534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66535       };
66536     } catch (...) {
66537       {
66538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66539       };
66540     }
66541   }
66542 }
66543
66544
66545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
66546   float jresult ;
66547   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66548   float result;
66549
66550   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66551   {
66552     try {
66553       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
66554     } catch (std::out_of_range& e) {
66555       {
66556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66557       };
66558     } catch (std::exception& e) {
66559       {
66560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66561       };
66562     } catch (...) {
66563       {
66564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66565       };
66566     }
66567   }
66568   jresult = result;
66569   return jresult;
66570 }
66571
66572
66573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
66574   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66575
66576   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66577   {
66578     try {
66579       (arg1)->Refresh();
66580     } catch (std::out_of_range& e) {
66581       {
66582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66583       };
66584     } catch (std::exception& e) {
66585       {
66586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66587       };
66588     } catch (...) {
66589       {
66590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66591       };
66592     }
66593   }
66594 }
66595
66596
66597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
66598   void * jresult ;
66599   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66600   Dali::Toolkit::ItemId arg2 ;
66601   Dali::Actor result;
66602
66603   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66604   arg2 = (Dali::Toolkit::ItemId)jarg2;
66605   {
66606     try {
66607       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
66608     } catch (std::out_of_range& e) {
66609       {
66610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66611       };
66612     } catch (std::exception& e) {
66613       {
66614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66615       };
66616     } catch (...) {
66617       {
66618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66619       };
66620     }
66621   }
66622   jresult = new Dali::Actor((const Dali::Actor &)result);
66623   return jresult;
66624 }
66625
66626
66627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
66628   unsigned int jresult ;
66629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66630   Dali::Actor arg2 ;
66631   Dali::Actor *argp2 ;
66632   Dali::Toolkit::ItemId result;
66633
66634   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66635   argp2 = (Dali::Actor *)jarg2;
66636   if (!argp2) {
66637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66638     return 0;
66639   }
66640   arg2 = *argp2;
66641   {
66642     try {
66643       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
66644     } catch (std::out_of_range& e) {
66645       {
66646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (std::exception& e) {
66649       {
66650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66651       };
66652     } catch (...) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66655       };
66656     }
66657   }
66658   jresult = result;
66659   return jresult;
66660 }
66661
66662
66663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
66664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66665   Dali::Toolkit::Item arg2 ;
66666   float arg3 ;
66667   Dali::Toolkit::Item *argp2 ;
66668
66669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66670   argp2 = (Dali::Toolkit::Item *)jarg2;
66671   if (!argp2) {
66672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66673     return ;
66674   }
66675   arg2 = *argp2;
66676   arg3 = (float)jarg3;
66677   {
66678     try {
66679       (arg1)->InsertItem(arg2,arg3);
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_InsertItems(void * jarg1, void * jarg2, float jarg3) {
66698   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66699   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66700   float arg3 ;
66701
66702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66703   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66704   if (!arg2) {
66705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66706     return ;
66707   }
66708   arg3 = (float)jarg3;
66709   {
66710     try {
66711       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66712     } catch (std::out_of_range& e) {
66713       {
66714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66715       };
66716     } catch (std::exception& e) {
66717       {
66718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66719       };
66720     } catch (...) {
66721       {
66722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66723       };
66724     }
66725   }
66726 }
66727
66728
66729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
66730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66731   Dali::Toolkit::ItemId arg2 ;
66732   float arg3 ;
66733
66734   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66735   arg2 = (Dali::Toolkit::ItemId)jarg2;
66736   arg3 = (float)jarg3;
66737   {
66738     try {
66739       (arg1)->RemoveItem(arg2,arg3);
66740     } catch (std::out_of_range& e) {
66741       {
66742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66743       };
66744     } catch (std::exception& e) {
66745       {
66746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66747       };
66748     } catch (...) {
66749       {
66750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66751       };
66752     }
66753   }
66754 }
66755
66756
66757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
66758   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66759   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
66760   float arg3 ;
66761
66762   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66763   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
66764   if (!arg2) {
66765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
66766     return ;
66767   }
66768   arg3 = (float)jarg3;
66769   {
66770     try {
66771       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
66772     } catch (std::out_of_range& e) {
66773       {
66774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66775       };
66776     } catch (std::exception& e) {
66777       {
66778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66779       };
66780     } catch (...) {
66781       {
66782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66783       };
66784     }
66785   }
66786 }
66787
66788
66789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
66790   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66791   Dali::Toolkit::Item arg2 ;
66792   float arg3 ;
66793   Dali::Toolkit::Item *argp2 ;
66794
66795   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66796   argp2 = (Dali::Toolkit::Item *)jarg2;
66797   if (!argp2) {
66798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
66799     return ;
66800   }
66801   arg2 = *argp2;
66802   arg3 = (float)jarg3;
66803   {
66804     try {
66805       (arg1)->ReplaceItem(arg2,arg3);
66806     } catch (std::out_of_range& e) {
66807       {
66808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66809       };
66810     } catch (std::exception& e) {
66811       {
66812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66813       };
66814     } catch (...) {
66815       {
66816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66817       };
66818     }
66819   }
66820 }
66821
66822
66823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
66824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66825   Dali::Toolkit::ItemContainer *arg2 = 0 ;
66826   float arg3 ;
66827
66828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66829   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
66830   if (!arg2) {
66831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
66832     return ;
66833   }
66834   arg3 = (float)jarg3;
66835   {
66836     try {
66837       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
66838     } catch (std::out_of_range& e) {
66839       {
66840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66841       };
66842     } catch (std::exception& e) {
66843       {
66844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66845       };
66846     } catch (...) {
66847       {
66848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66849       };
66850     }
66851   }
66852 }
66853
66854
66855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
66856   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66857   Dali::Vector3 *arg2 = 0 ;
66858
66859   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66860   arg2 = (Dali::Vector3 *)jarg2;
66861   if (!arg2) {
66862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66863     return ;
66864   }
66865   {
66866     try {
66867       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
66868     } catch (std::out_of_range& e) {
66869       {
66870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66871       };
66872     } catch (std::exception& e) {
66873       {
66874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66875       };
66876     } catch (...) {
66877       {
66878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66879       };
66880     }
66881   }
66882 }
66883
66884
66885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
66886   void * jresult ;
66887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66888   Dali::Vector3 result;
66889
66890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66891   {
66892     try {
66893       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
66894     } catch (std::out_of_range& e) {
66895       {
66896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66897       };
66898     } catch (std::exception& e) {
66899       {
66900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66901       };
66902     } catch (...) {
66903       {
66904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66905       };
66906     }
66907   }
66908   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66909   return jresult;
66910 }
66911
66912
66913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
66914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66915   Dali::Vector3 *arg2 = 0 ;
66916
66917   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66918   arg2 = (Dali::Vector3 *)jarg2;
66919   if (!arg2) {
66920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66921     return ;
66922   }
66923   {
66924     try {
66925       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
66926     } catch (std::out_of_range& e) {
66927       {
66928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66929       };
66930     } catch (std::exception& e) {
66931       {
66932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66933       };
66934     } catch (...) {
66935       {
66936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66937       };
66938     }
66939   }
66940 }
66941
66942
66943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
66944   void * jresult ;
66945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66946   Dali::Vector3 result;
66947
66948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66949   {
66950     try {
66951       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
66952     } catch (std::out_of_range& e) {
66953       {
66954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66955       };
66956     } catch (std::exception& e) {
66957       {
66958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66959       };
66960     } catch (...) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66963       };
66964     }
66965   }
66966   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
66967   return jresult;
66968 }
66969
66970
66971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
66972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
66973   Dali::Toolkit::ItemRange *arg2 = 0 ;
66974
66975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
66976   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66977   if (!arg2) {
66978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
66979     return ;
66980   }
66981   {
66982     try {
66983       (arg1)->GetItemsRange(*arg2);
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66991       };
66992     } catch (...) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66995       };
66996     }
66997   }
66998 }
66999
67000
67001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
67002   void * jresult ;
67003   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67004   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
67005
67006   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67007   {
67008     try {
67009       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67017       };
67018     } catch (...) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67021       };
67022     }
67023   }
67024   jresult = (void *)result;
67025   return jresult;
67026 }
67027
67028
67029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
67030   Dali::Vector3 *arg1 = 0 ;
67031   PropertyInputContainer *arg2 = 0 ;
67032
67033   arg1 = (Dali::Vector3 *)jarg1;
67034   if (!arg1) {
67035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67036     return ;
67037   }
67038   arg2 = (PropertyInputContainer *)jarg2;
67039   if (!arg2) {
67040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
67041     return ;
67042   }
67043   {
67044     try {
67045       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
67046     } catch (std::out_of_range& e) {
67047       {
67048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67049       };
67050     } catch (std::exception& e) {
67051       {
67052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67053       };
67054     } catch (...) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67057       };
67058     }
67059   }
67060 }
67061
67062
67063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
67064   Dali::Vector3 *arg1 = 0 ;
67065   PropertyInputContainer *arg2 = 0 ;
67066
67067   arg1 = (Dali::Vector3 *)jarg1;
67068   if (!arg1) {
67069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67070     return ;
67071   }
67072   arg2 = (PropertyInputContainer *)jarg2;
67073   if (!arg2) {
67074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
67075     return ;
67076   }
67077   {
67078     try {
67079       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
67080     } catch (std::out_of_range& e) {
67081       {
67082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67083       };
67084     } catch (std::exception& e) {
67085       {
67086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67087       };
67088     } catch (...) {
67089       {
67090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67091       };
67092     }
67093   }
67094 }
67095
67096
67097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
67098   void * jresult ;
67099   Dali::Toolkit::ScrollViewEffect *result = 0 ;
67100
67101   {
67102     try {
67103       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
67104     } catch (std::out_of_range& e) {
67105       {
67106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67107       };
67108     } catch (std::exception& e) {
67109       {
67110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67111       };
67112     } catch (...) {
67113       {
67114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67115       };
67116     }
67117   }
67118   jresult = (void *)result;
67119   return jresult;
67120 }
67121
67122
67123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
67124   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
67125
67126   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
67127   {
67128     try {
67129       delete arg1;
67130     } catch (std::out_of_range& e) {
67131       {
67132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67133       };
67134     } catch (std::exception& e) {
67135       {
67136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67137       };
67138     } catch (...) {
67139       {
67140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67141       };
67142     }
67143   }
67144 }
67145
67146
67147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
67148   void * jresult ;
67149   Dali::Path arg1 ;
67150   Dali::Vector3 *arg2 = 0 ;
67151   Dali::Property::Index arg3 ;
67152   Dali::Vector3 *arg4 = 0 ;
67153   unsigned int arg5 ;
67154   Dali::Path *argp1 ;
67155   Dali::Toolkit::ScrollViewPagePathEffect result;
67156
67157   argp1 = (Dali::Path *)jarg1;
67158   if (!argp1) {
67159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
67160     return 0;
67161   }
67162   arg1 = *argp1;
67163   arg2 = (Dali::Vector3 *)jarg2;
67164   if (!arg2) {
67165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67166     return 0;
67167   }
67168   arg3 = (Dali::Property::Index)jarg3;
67169   arg4 = (Dali::Vector3 *)jarg4;
67170   if (!arg4) {
67171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67172     return 0;
67173   }
67174   arg5 = (unsigned int)jarg5;
67175   {
67176     try {
67177       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
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 = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67193   return jresult;
67194 }
67195
67196
67197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
67198   void * jresult ;
67199   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
67200
67201   {
67202     try {
67203       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
67204     } catch (std::out_of_range& e) {
67205       {
67206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67207       };
67208     } catch (std::exception& e) {
67209       {
67210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67211       };
67212     } catch (...) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67215       };
67216     }
67217   }
67218   jresult = (void *)result;
67219   return jresult;
67220 }
67221
67222
67223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
67224   void * jresult ;
67225   Dali::BaseHandle arg1 ;
67226   Dali::BaseHandle *argp1 ;
67227   Dali::Toolkit::ScrollViewPagePathEffect result;
67228
67229   argp1 = (Dali::BaseHandle *)jarg1;
67230   if (!argp1) {
67231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67232     return 0;
67233   }
67234   arg1 = *argp1;
67235   {
67236     try {
67237       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
67238     } catch (std::out_of_range& e) {
67239       {
67240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67241       };
67242     } catch (std::exception& e) {
67243       {
67244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67245       };
67246     } catch (...) {
67247       {
67248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67249       };
67250     }
67251   }
67252   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
67253   return jresult;
67254 }
67255
67256
67257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
67258   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67259   Dali::Actor arg2 ;
67260   unsigned int arg3 ;
67261   Dali::Actor *argp2 ;
67262
67263   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67264   argp2 = (Dali::Actor *)jarg2;
67265   if (!argp2) {
67266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67267     return ;
67268   }
67269   arg2 = *argp2;
67270   arg3 = (unsigned int)jarg3;
67271   {
67272     try {
67273       (arg1)->ApplyToPage(arg2,arg3);
67274     } catch (std::out_of_range& e) {
67275       {
67276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67277       };
67278     } catch (std::exception& e) {
67279       {
67280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67281       };
67282     } catch (...) {
67283       {
67284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67285       };
67286     }
67287   }
67288 }
67289
67290
67291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
67292   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
67293
67294   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
67295   {
67296     try {
67297       delete arg1;
67298     } catch (std::out_of_range& e) {
67299       {
67300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67301       };
67302     } catch (std::exception& e) {
67303       {
67304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67305       };
67306     } catch (...) {
67307       {
67308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67309       };
67310     }
67311   }
67312 }
67313
67314
67315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
67316   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67317   Dali::Toolkit::ClampState arg2 ;
67318
67319   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67320   arg2 = (Dali::Toolkit::ClampState)jarg2;
67321   if (arg1) (arg1)->x = arg2;
67322 }
67323
67324
67325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
67326   int jresult ;
67327   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67328   Dali::Toolkit::ClampState result;
67329
67330   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67331   result = (Dali::Toolkit::ClampState) ((arg1)->x);
67332   jresult = (int)result;
67333   return jresult;
67334 }
67335
67336
67337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
67338   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67339   Dali::Toolkit::ClampState arg2 ;
67340
67341   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67342   arg2 = (Dali::Toolkit::ClampState)jarg2;
67343   if (arg1) (arg1)->y = arg2;
67344 }
67345
67346
67347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
67348   int jresult ;
67349   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67350   Dali::Toolkit::ClampState result;
67351
67352   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67353   result = (Dali::Toolkit::ClampState) ((arg1)->y);
67354   jresult = (int)result;
67355   return jresult;
67356 }
67357
67358
67359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
67360   void * jresult ;
67361   Dali::Toolkit::ClampState2D *result = 0 ;
67362
67363   {
67364     try {
67365       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
67366     } catch (std::out_of_range& e) {
67367       {
67368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67369       };
67370     } catch (std::exception& e) {
67371       {
67372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67373       };
67374     } catch (...) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67377       };
67378     }
67379   }
67380   jresult = (void *)result;
67381   return jresult;
67382 }
67383
67384
67385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
67386   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
67387
67388   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
67389   {
67390     try {
67391       delete arg1;
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67403       };
67404     }
67405   }
67406 }
67407
67408
67409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
67410   void * jresult ;
67411   float arg1 ;
67412   float arg2 ;
67413   bool arg3 ;
67414   Dali::Toolkit::RulerDomain *result = 0 ;
67415
67416   arg1 = (float)jarg1;
67417   arg2 = (float)jarg2;
67418   arg3 = jarg3 ? true : false;
67419   {
67420     try {
67421       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (...) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67433       };
67434     }
67435   }
67436   jresult = (void *)result;
67437   return jresult;
67438 }
67439
67440
67441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
67442   void * jresult ;
67443   float arg1 ;
67444   float arg2 ;
67445   Dali::Toolkit::RulerDomain *result = 0 ;
67446
67447   arg1 = (float)jarg1;
67448   arg2 = (float)jarg2;
67449   {
67450     try {
67451       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
67452     } catch (std::out_of_range& e) {
67453       {
67454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67455       };
67456     } catch (std::exception& e) {
67457       {
67458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67459       };
67460     } catch (...) {
67461       {
67462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67463       };
67464     }
67465   }
67466   jresult = (void *)result;
67467   return jresult;
67468 }
67469
67470
67471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
67472   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67473   float arg2 ;
67474
67475   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67476   arg2 = (float)jarg2;
67477   if (arg1) (arg1)->min = arg2;
67478 }
67479
67480
67481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
67482   float jresult ;
67483   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67484   float result;
67485
67486   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67487   result = (float) ((arg1)->min);
67488   jresult = result;
67489   return jresult;
67490 }
67491
67492
67493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
67494   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67495   float arg2 ;
67496
67497   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67498   arg2 = (float)jarg2;
67499   if (arg1) (arg1)->max = arg2;
67500 }
67501
67502
67503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
67504   float jresult ;
67505   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67506   float result;
67507
67508   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67509   result = (float) ((arg1)->max);
67510   jresult = result;
67511   return jresult;
67512 }
67513
67514
67515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
67516   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67517   bool arg2 ;
67518
67519   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67520   arg2 = jarg2 ? true : false;
67521   if (arg1) (arg1)->enabled = arg2;
67522 }
67523
67524
67525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
67526   unsigned int jresult ;
67527   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67528   bool result;
67529
67530   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67531   result = (bool) ((arg1)->enabled);
67532   jresult = result;
67533   return jresult;
67534 }
67535
67536
67537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
67538   float jresult ;
67539   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67540   float arg2 ;
67541   float arg3 ;
67542   float arg4 ;
67543   float result;
67544
67545   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67546   arg2 = (float)jarg2;
67547   arg3 = (float)jarg3;
67548   arg4 = (float)jarg4;
67549   {
67550     try {
67551       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
67552     } catch (std::out_of_range& e) {
67553       {
67554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67555       };
67556     } catch (std::exception& e) {
67557       {
67558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67559       };
67560     } catch (...) {
67561       {
67562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67563       };
67564     }
67565   }
67566   jresult = result;
67567   return jresult;
67568 }
67569
67570
67571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
67572   float jresult ;
67573   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67574   float arg2 ;
67575   float arg3 ;
67576   float result;
67577
67578   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67579   arg2 = (float)jarg2;
67580   arg3 = (float)jarg3;
67581   {
67582     try {
67583       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67591       };
67592     } catch (...) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67595       };
67596     }
67597   }
67598   jresult = result;
67599   return jresult;
67600 }
67601
67602
67603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
67604   float jresult ;
67605   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67606   float arg2 ;
67607   float result;
67608
67609   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67610   arg2 = (float)jarg2;
67611   {
67612     try {
67613       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
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 float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
67634   float jresult ;
67635   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67636   float arg2 ;
67637   float arg3 ;
67638   float arg4 ;
67639   Dali::Toolkit::ClampState *arg5 = 0 ;
67640   float result;
67641
67642   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67643   arg2 = (float)jarg2;
67644   arg3 = (float)jarg3;
67645   arg4 = (float)jarg4;
67646   arg5 = (Dali::Toolkit::ClampState *)jarg5;
67647   if (!arg5) {
67648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
67649     return 0;
67650   }
67651   {
67652     try {
67653       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
67654     } catch (std::out_of_range& e) {
67655       {
67656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67657       };
67658     } catch (std::exception& e) {
67659       {
67660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67661       };
67662     } catch (...) {
67663       {
67664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67665       };
67666     }
67667   }
67668   jresult = result;
67669   return jresult;
67670 }
67671
67672
67673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
67674   float jresult ;
67675   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67676   float result;
67677
67678   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67679   {
67680     try {
67681       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
67682     } catch (std::out_of_range& e) {
67683       {
67684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67685       };
67686     } catch (std::exception& e) {
67687       {
67688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (...) {
67691       {
67692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67693       };
67694     }
67695   }
67696   jresult = result;
67697   return jresult;
67698 }
67699
67700
67701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
67702   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
67703
67704   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
67705   {
67706     try {
67707       delete arg1;
67708     } catch (std::out_of_range& e) {
67709       {
67710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67711       };
67712     } catch (std::exception& e) {
67713       {
67714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67715       };
67716     } catch (...) {
67717       {
67718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67719       };
67720     }
67721   }
67722 }
67723
67724
67725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
67726   float jresult ;
67727   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67728   float arg2 ;
67729   float arg3 ;
67730   float result;
67731
67732   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67733   arg2 = (float)jarg2;
67734   arg3 = (float)jarg3;
67735   {
67736     try {
67737       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
67738     } catch (std::out_of_range& e) {
67739       {
67740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67741       };
67742     } catch (std::exception& e) {
67743       {
67744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67745       };
67746     } catch (...) {
67747       {
67748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67749       };
67750     }
67751   }
67752   jresult = result;
67753   return jresult;
67754 }
67755
67756
67757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
67758   float jresult ;
67759   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67760   float arg2 ;
67761   float result;
67762
67763   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67764   arg2 = (float)jarg2;
67765   {
67766     try {
67767       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
67768     } catch (std::out_of_range& e) {
67769       {
67770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67771       };
67772     } catch (std::exception& e) {
67773       {
67774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (...) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67779       };
67780     }
67781   }
67782   jresult = result;
67783   return jresult;
67784 }
67785
67786
67787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
67788   float jresult ;
67789   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67790   unsigned int arg2 ;
67791   unsigned int *arg3 = 0 ;
67792   bool arg4 ;
67793   float result;
67794
67795   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67796   arg2 = (unsigned int)jarg2;
67797   arg3 = (unsigned int *)jarg3;
67798   arg4 = jarg4 ? true : false;
67799   {
67800     try {
67801       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
67802     } catch (std::out_of_range& e) {
67803       {
67804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67805       };
67806     } catch (std::exception& e) {
67807       {
67808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67809       };
67810     } catch (...) {
67811       {
67812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67813       };
67814     }
67815   }
67816   jresult = result;
67817   return jresult;
67818 }
67819
67820
67821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
67822   unsigned int jresult ;
67823   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67824   float arg2 ;
67825   bool arg3 ;
67826   unsigned int result;
67827
67828   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67829   arg2 = (float)jarg2;
67830   arg3 = jarg3 ? true : false;
67831   {
67832     try {
67833       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
67834     } catch (std::out_of_range& e) {
67835       {
67836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (std::exception& e) {
67839       {
67840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67841       };
67842     } catch (...) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67845       };
67846     }
67847   }
67848   jresult = result;
67849   return jresult;
67850 }
67851
67852
67853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
67854   unsigned int jresult ;
67855   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67856   unsigned int result;
67857
67858   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67859   {
67860     try {
67861       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
67862     } catch (std::out_of_range& e) {
67863       {
67864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67865       };
67866     } catch (std::exception& e) {
67867       {
67868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67869       };
67870     } catch (...) {
67871       {
67872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67873       };
67874     }
67875   }
67876   jresult = result;
67877   return jresult;
67878 }
67879
67880
67881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
67882   int jresult ;
67883   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67884   Dali::Toolkit::Ruler::RulerType result;
67885
67886   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67887   {
67888     try {
67889       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67901       };
67902     }
67903   }
67904   jresult = (int)result;
67905   return jresult;
67906 }
67907
67908
67909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
67910   unsigned int jresult ;
67911   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67912   bool result;
67913
67914   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67915   {
67916     try {
67917       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (...) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67929       };
67930     }
67931   }
67932   jresult = result;
67933   return jresult;
67934 }
67935
67936
67937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
67938   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67939
67940   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67941   {
67942     try {
67943       (arg1)->Enable();
67944     } catch (std::out_of_range& e) {
67945       {
67946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67947       };
67948     } catch (std::exception& e) {
67949       {
67950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67951       };
67952     } catch (...) {
67953       {
67954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67955       };
67956     }
67957   }
67958 }
67959
67960
67961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
67962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67963
67964   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67965   {
67966     try {
67967       (arg1)->Disable();
67968     } catch (std::out_of_range& e) {
67969       {
67970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67971       };
67972     } catch (std::exception& e) {
67973       {
67974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (...) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67979       };
67980     }
67981   }
67982 }
67983
67984
67985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
67986   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
67987   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
67988   Dali::Toolkit::RulerDomain *argp2 ;
67989
67990   arg1 = (Dali::Toolkit::Ruler *)jarg1;
67991   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
67992   if (!argp2) {
67993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
67994     return ;
67995   }
67996   arg2 = *argp2;
67997   {
67998     try {
67999       (arg1)->SetDomain(arg2);
68000     } catch (std::out_of_range& e) {
68001       {
68002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68003       };
68004     } catch (std::exception& e) {
68005       {
68006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68007       };
68008     } catch (...) {
68009       {
68010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68011       };
68012     }
68013   }
68014 }
68015
68016
68017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
68018   void * jresult ;
68019   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68020   Dali::Toolkit::RulerDomain *result = 0 ;
68021
68022   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68023   {
68024     try {
68025       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
68026     } catch (std::out_of_range& e) {
68027       {
68028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (std::exception& e) {
68031       {
68032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68033       };
68034     } catch (...) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68037       };
68038     }
68039   }
68040   jresult = (void *)result;
68041   return jresult;
68042 }
68043
68044
68045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
68046   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68047
68048   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68049   {
68050     try {
68051       (arg1)->DisableDomain();
68052     } catch (std::out_of_range& e) {
68053       {
68054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68055       };
68056     } catch (std::exception& e) {
68057       {
68058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68059       };
68060     } catch (...) {
68061       {
68062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68063       };
68064     }
68065   }
68066 }
68067
68068
68069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
68070   float jresult ;
68071   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68072   float arg2 ;
68073   float arg3 ;
68074   float arg4 ;
68075   float result;
68076
68077   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68078   arg2 = (float)jarg2;
68079   arg3 = (float)jarg3;
68080   arg4 = (float)jarg4;
68081   {
68082     try {
68083       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
68084     } catch (std::out_of_range& e) {
68085       {
68086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (std::exception& e) {
68089       {
68090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098   jresult = result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
68104   float jresult ;
68105   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68106   float arg2 ;
68107   float arg3 ;
68108   float result;
68109
68110   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68111   arg2 = (float)jarg2;
68112   arg3 = (float)jarg3;
68113   {
68114     try {
68115       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
68116     } catch (std::out_of_range& e) {
68117       {
68118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (std::exception& e) {
68121       {
68122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (...) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68127       };
68128     }
68129   }
68130   jresult = result;
68131   return jresult;
68132 }
68133
68134
68135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
68136   float jresult ;
68137   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68138   float arg2 ;
68139   float result;
68140
68141   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68142   arg2 = (float)jarg2;
68143   {
68144     try {
68145       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
68146     } catch (std::out_of_range& e) {
68147       {
68148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68149       };
68150     } catch (std::exception& e) {
68151       {
68152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68153       };
68154     } catch (...) {
68155       {
68156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68157       };
68158     }
68159   }
68160   jresult = result;
68161   return jresult;
68162 }
68163
68164
68165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
68166   float jresult ;
68167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68168   float arg2 ;
68169   float arg3 ;
68170   float arg4 ;
68171   Dali::Toolkit::ClampState *arg5 = 0 ;
68172   float result;
68173
68174   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68175   arg2 = (float)jarg2;
68176   arg3 = (float)jarg3;
68177   arg4 = (float)jarg4;
68178   arg5 = (Dali::Toolkit::ClampState *)jarg5;
68179   if (!arg5) {
68180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68181     return 0;
68182   }
68183   {
68184     try {
68185       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
68186     } catch (std::out_of_range& e) {
68187       {
68188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68189       };
68190     } catch (std::exception& e) {
68191       {
68192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68193       };
68194     } catch (...) {
68195       {
68196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68197       };
68198     }
68199   }
68200   jresult = result;
68201   return jresult;
68202 }
68203
68204
68205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
68206   float jresult ;
68207   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68208   float arg2 ;
68209   float arg3 ;
68210   float arg4 ;
68211   float arg5 ;
68212   float result;
68213
68214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68215   arg2 = (float)jarg2;
68216   arg3 = (float)jarg3;
68217   arg4 = (float)jarg4;
68218   arg5 = (float)jarg5;
68219   {
68220     try {
68221       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
68222     } catch (std::out_of_range& e) {
68223       {
68224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68225       };
68226     } catch (std::exception& e) {
68227       {
68228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (...) {
68231       {
68232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68233       };
68234     }
68235   }
68236   jresult = result;
68237   return jresult;
68238 }
68239
68240
68241 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
68242   float jresult ;
68243   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68244   float arg2 ;
68245   float arg3 ;
68246   float arg4 ;
68247   float result;
68248
68249   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68250   arg2 = (float)jarg2;
68251   arg3 = (float)jarg3;
68252   arg4 = (float)jarg4;
68253   {
68254     try {
68255       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68263       };
68264     } catch (...) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68267       };
68268     }
68269   }
68270   jresult = result;
68271   return jresult;
68272 }
68273
68274
68275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
68276   float jresult ;
68277   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68278   float arg2 ;
68279   float arg3 ;
68280   float result;
68281
68282   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68283   arg2 = (float)jarg2;
68284   arg3 = (float)jarg3;
68285   {
68286     try {
68287       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
68288     } catch (std::out_of_range& e) {
68289       {
68290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68291       };
68292     } catch (std::exception& e) {
68293       {
68294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68295       };
68296     } catch (...) {
68297       {
68298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68299       };
68300     }
68301   }
68302   jresult = result;
68303   return jresult;
68304 }
68305
68306
68307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
68308   float jresult ;
68309   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68310   float arg2 ;
68311   float result;
68312
68313   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68314   arg2 = (float)jarg2;
68315   {
68316     try {
68317       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
68318     } catch (std::out_of_range& e) {
68319       {
68320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68321       };
68322     } catch (std::exception& e) {
68323       {
68324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (...) {
68327       {
68328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68329       };
68330     }
68331   }
68332   jresult = result;
68333   return jresult;
68334 }
68335
68336
68337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
68338   float jresult ;
68339   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
68340   float arg2 ;
68341   float arg3 ;
68342   float arg4 ;
68343   float arg5 ;
68344   Dali::Toolkit::ClampState *arg6 = 0 ;
68345   float result;
68346
68347   arg1 = (Dali::Toolkit::Ruler *)jarg1;
68348   arg2 = (float)jarg2;
68349   arg3 = (float)jarg3;
68350   arg4 = (float)jarg4;
68351   arg5 = (float)jarg5;
68352   arg6 = (Dali::Toolkit::ClampState *)jarg6;
68353   if (!arg6) {
68354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
68355     return 0;
68356   }
68357   {
68358     try {
68359       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
68360     } catch (std::out_of_range& e) {
68361       {
68362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68363       };
68364     } catch (std::exception& e) {
68365       {
68366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68367       };
68368     } catch (...) {
68369       {
68370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68371       };
68372     }
68373   }
68374   jresult = result;
68375   return jresult;
68376 }
68377
68378
68379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
68380   void * jresult ;
68381   Dali::Toolkit::DefaultRuler *result = 0 ;
68382
68383   {
68384     try {
68385       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
68386     } catch (std::out_of_range& e) {
68387       {
68388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68389       };
68390     } catch (std::exception& e) {
68391       {
68392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68393       };
68394     } catch (...) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68397       };
68398     }
68399   }
68400   jresult = (void *)result;
68401   return jresult;
68402 }
68403
68404
68405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68406   float jresult ;
68407   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68408   float arg2 ;
68409   float arg3 ;
68410   float result;
68411
68412   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68413   arg2 = (float)jarg2;
68414   arg3 = (float)jarg3;
68415   {
68416     try {
68417       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
68418     } catch (std::out_of_range& e) {
68419       {
68420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68421       };
68422     } catch (std::exception& e) {
68423       {
68424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68425       };
68426     } catch (...) {
68427       {
68428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68429       };
68430     }
68431   }
68432   jresult = result;
68433   return jresult;
68434 }
68435
68436
68437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68438   float jresult ;
68439   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68440   unsigned int arg2 ;
68441   unsigned int *arg3 = 0 ;
68442   bool arg4 ;
68443   float result;
68444
68445   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68446   arg2 = (unsigned int)jarg2;
68447   arg3 = (unsigned int *)jarg3;
68448   arg4 = jarg4 ? true : false;
68449   {
68450     try {
68451       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68452     } catch (std::out_of_range& e) {
68453       {
68454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68455       };
68456     } catch (std::exception& e) {
68457       {
68458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (...) {
68461       {
68462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68463       };
68464     }
68465   }
68466   jresult = result;
68467   return jresult;
68468 }
68469
68470
68471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68472   unsigned int jresult ;
68473   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68474   float arg2 ;
68475   bool arg3 ;
68476   unsigned int result;
68477
68478   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68479   arg2 = (float)jarg2;
68480   arg3 = jarg3 ? true : false;
68481   {
68482     try {
68483       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68484     } catch (std::out_of_range& e) {
68485       {
68486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68487       };
68488     } catch (std::exception& e) {
68489       {
68490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68491       };
68492     } catch (...) {
68493       {
68494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68495       };
68496     }
68497   }
68498   jresult = result;
68499   return jresult;
68500 }
68501
68502
68503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
68504   unsigned int jresult ;
68505   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68506   unsigned int result;
68507
68508   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68509   {
68510     try {
68511       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
68512     } catch (std::out_of_range& e) {
68513       {
68514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68515       };
68516     } catch (std::exception& e) {
68517       {
68518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68519       };
68520     } catch (...) {
68521       {
68522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68523       };
68524     }
68525   }
68526   jresult = result;
68527   return jresult;
68528 }
68529
68530
68531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
68532   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
68533
68534   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
68535   {
68536     try {
68537       delete arg1;
68538     } catch (std::out_of_range& e) {
68539       {
68540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68541       };
68542     } catch (std::exception& e) {
68543       {
68544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68545       };
68546     } catch (...) {
68547       {
68548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68549       };
68550     }
68551   }
68552 }
68553
68554
68555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
68556   void * jresult ;
68557   float arg1 ;
68558   Dali::Toolkit::FixedRuler *result = 0 ;
68559
68560   arg1 = (float)jarg1;
68561   {
68562     try {
68563       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68575       };
68576     }
68577   }
68578   jresult = (void *)result;
68579   return jresult;
68580 }
68581
68582
68583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
68584   void * jresult ;
68585   Dali::Toolkit::FixedRuler *result = 0 ;
68586
68587   {
68588     try {
68589       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
68590     } catch (std::out_of_range& e) {
68591       {
68592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68593       };
68594     } catch (std::exception& e) {
68595       {
68596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68601       };
68602     }
68603   }
68604   jresult = (void *)result;
68605   return jresult;
68606 }
68607
68608
68609 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
68610   float jresult ;
68611   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68612   float arg2 ;
68613   float arg3 ;
68614   float result;
68615
68616   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68617   arg2 = (float)jarg2;
68618   arg3 = (float)jarg3;
68619   {
68620     try {
68621       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
68622     } catch (std::out_of_range& e) {
68623       {
68624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68625       };
68626     } catch (std::exception& e) {
68627       {
68628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68629       };
68630     } catch (...) {
68631       {
68632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68633       };
68634     }
68635   }
68636   jresult = result;
68637   return jresult;
68638 }
68639
68640
68641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
68642   float jresult ;
68643   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68644   unsigned int arg2 ;
68645   unsigned int *arg3 = 0 ;
68646   bool arg4 ;
68647   float result;
68648
68649   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68650   arg2 = (unsigned int)jarg2;
68651   arg3 = (unsigned int *)jarg3;
68652   arg4 = jarg4 ? true : false;
68653   {
68654     try {
68655       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
68656     } catch (std::out_of_range& e) {
68657       {
68658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68659       };
68660     } catch (std::exception& e) {
68661       {
68662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68663       };
68664     } catch (...) {
68665       {
68666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68667       };
68668     }
68669   }
68670   jresult = result;
68671   return jresult;
68672 }
68673
68674
68675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
68676   unsigned int jresult ;
68677   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68678   float arg2 ;
68679   bool arg3 ;
68680   unsigned int result;
68681
68682   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68683   arg2 = (float)jarg2;
68684   arg3 = jarg3 ? true : false;
68685   {
68686     try {
68687       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
68688     } catch (std::out_of_range& e) {
68689       {
68690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68691       };
68692     } catch (std::exception& e) {
68693       {
68694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68695       };
68696     } catch (...) {
68697       {
68698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68699       };
68700     }
68701   }
68702   jresult = result;
68703   return jresult;
68704 }
68705
68706
68707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
68708   unsigned int jresult ;
68709   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68710   unsigned int result;
68711
68712   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68713   {
68714     try {
68715       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
68716     } catch (std::out_of_range& e) {
68717       {
68718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68719       };
68720     } catch (std::exception& e) {
68721       {
68722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68723       };
68724     } catch (...) {
68725       {
68726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68727       };
68728     }
68729   }
68730   jresult = result;
68731   return jresult;
68732 }
68733
68734
68735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
68736   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
68737
68738   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
68739   {
68740     try {
68741       delete arg1;
68742     } catch (std::out_of_range& e) {
68743       {
68744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68745       };
68746     } catch (std::exception& e) {
68747       {
68748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68749       };
68750     } catch (...) {
68751       {
68752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68753       };
68754     }
68755   }
68756 }
68757
68758
68759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
68760   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68761   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68762
68763   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68764   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68765   if (arg1) (arg1)->scale = *arg2;
68766 }
68767
68768
68769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
68770   void * jresult ;
68771   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68772   Dali::Toolkit::ClampState2D *result = 0 ;
68773
68774   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68775   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
68776   jresult = (void *)result;
68777   return jresult;
68778 }
68779
68780
68781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
68782   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68783   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
68784
68785   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68786   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
68787   if (arg1) (arg1)->position = *arg2;
68788 }
68789
68790
68791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
68792   void * jresult ;
68793   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68794   Dali::Toolkit::ClampState2D *result = 0 ;
68795
68796   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68797   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
68798   jresult = (void *)result;
68799   return jresult;
68800 }
68801
68802
68803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
68804   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68805   Dali::Toolkit::ClampState arg2 ;
68806
68807   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68808   arg2 = (Dali::Toolkit::ClampState)jarg2;
68809   if (arg1) (arg1)->rotation = arg2;
68810 }
68811
68812
68813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
68814   int jresult ;
68815   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68816   Dali::Toolkit::ClampState result;
68817
68818   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68819   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
68820   jresult = (int)result;
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
68826   void * jresult ;
68827   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
68828
68829   {
68830     try {
68831       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
68832     } catch (std::out_of_range& e) {
68833       {
68834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68835       };
68836     } catch (std::exception& e) {
68837       {
68838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68839       };
68840     } catch (...) {
68841       {
68842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68843       };
68844     }
68845   }
68846   jresult = (void *)result;
68847   return jresult;
68848 }
68849
68850
68851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
68852   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
68853
68854   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
68855   {
68856     try {
68857       delete arg1;
68858     } catch (std::out_of_range& e) {
68859       {
68860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68861       };
68862     } catch (std::exception& e) {
68863       {
68864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68865       };
68866     } catch (...) {
68867       {
68868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68869       };
68870     }
68871   }
68872 }
68873
68874
68875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
68876   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68877   Dali::Toolkit::SnapType arg2 ;
68878
68879   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68880   arg2 = (Dali::Toolkit::SnapType)jarg2;
68881   if (arg1) (arg1)->type = arg2;
68882 }
68883
68884
68885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
68886   int jresult ;
68887   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68888   Dali::Toolkit::SnapType result;
68889
68890   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68891   result = (Dali::Toolkit::SnapType) ((arg1)->type);
68892   jresult = (int)result;
68893   return jresult;
68894 }
68895
68896
68897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
68898   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68899   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
68900
68901   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68902   arg2 = (Dali::Vector2 *)jarg2;
68903   if (arg1) (arg1)->position = *arg2;
68904 }
68905
68906
68907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
68908   void * jresult ;
68909   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68910   Dali::Vector2 *result = 0 ;
68911
68912   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68913   result = (Dali::Vector2 *)& ((arg1)->position);
68914   jresult = (void *)result;
68915   return jresult;
68916 }
68917
68918
68919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
68920   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68921   float arg2 ;
68922
68923   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68924   arg2 = (float)jarg2;
68925   if (arg1) (arg1)->duration = arg2;
68926 }
68927
68928
68929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
68930   float jresult ;
68931   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68932   float result;
68933
68934   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68935   result = (float) ((arg1)->duration);
68936   jresult = result;
68937   return jresult;
68938 }
68939
68940
68941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
68942   void * jresult ;
68943   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
68944
68945   {
68946     try {
68947       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
68948     } catch (std::out_of_range& e) {
68949       {
68950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68951       };
68952     } catch (std::exception& e) {
68953       {
68954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68955       };
68956     } catch (...) {
68957       {
68958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68959       };
68960     }
68961   }
68962   jresult = (void *)result;
68963   return jresult;
68964 }
68965
68966
68967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
68968   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
68969
68970   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
68971   {
68972     try {
68973       delete arg1;
68974     } catch (std::out_of_range& e) {
68975       {
68976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68977       };
68978     } catch (std::exception& e) {
68979       {
68980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68981       };
68982     } catch (...) {
68983       {
68984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68985       };
68986     }
68987   }
68988 }
68989
68990
68991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
68992   int jresult ;
68993   int result;
68994
68995   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
68996   jresult = (int)result;
68997   return jresult;
68998 }
68999
69000
69001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
69002   int jresult ;
69003   int result;
69004
69005   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
69006   jresult = (int)result;
69007   return jresult;
69008 }
69009
69010
69011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
69012   int jresult ;
69013   int result;
69014
69015   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
69016   jresult = (int)result;
69017   return jresult;
69018 }
69019
69020
69021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69022   int jresult ;
69023   int result;
69024
69025   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69026   jresult = (int)result;
69027   return jresult;
69028 }
69029
69030
69031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
69032   int jresult ;
69033   int result;
69034
69035   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
69036   jresult = (int)result;
69037   return jresult;
69038 }
69039
69040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
69041   int jresult ;
69042   int result;
69043
69044   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
69045   jresult = (int)result;
69046   return jresult;
69047 }
69048
69049
69050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
69051   int jresult ;
69052   int result;
69053
69054   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
69055   jresult = (int)result;
69056   return jresult;
69057 }
69058
69059
69060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
69061   int jresult ;
69062   int result;
69063
69064   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
69065   jresult = (int)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
69071   int jresult ;
69072   int result;
69073
69074   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
69075   jresult = (int)result;
69076   return jresult;
69077 }
69078
69079
69080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
69081   int jresult ;
69082   int result;
69083
69084   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
69085   jresult = (int)result;
69086   return jresult;
69087 }
69088
69089
69090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
69091   int jresult ;
69092   int result;
69093
69094   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
69095   jresult = (int)result;
69096   return jresult;
69097 }
69098
69099
69100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
69101   int jresult ;
69102   int result;
69103
69104   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
69105   jresult = (int)result;
69106   return jresult;
69107 }
69108
69109
69110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
69111   int jresult ;
69112   int result;
69113
69114   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
69115   jresult = (int)result;
69116   return jresult;
69117 }
69118
69119
69120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
69121   int jresult ;
69122   int result;
69123
69124   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
69125   jresult = (int)result;
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
69131   int jresult ;
69132   int result;
69133
69134   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
69135   jresult = (int)result;
69136   return jresult;
69137 }
69138
69139
69140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
69141   int jresult ;
69142   int result;
69143
69144   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
69145   jresult = (int)result;
69146   return jresult;
69147 }
69148
69149
69150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
69151   int jresult ;
69152   int result;
69153
69154   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
69155   jresult = (int)result;
69156   return jresult;
69157 }
69158
69159
69160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
69161   int jresult ;
69162   int result;
69163
69164   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
69165   jresult = (int)result;
69166   return jresult;
69167 }
69168
69169
69170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
69171   int jresult ;
69172   int result;
69173
69174   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
69175   jresult = (int)result;
69176   return jresult;
69177 }
69178
69179
69180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
69181   int jresult ;
69182   int result;
69183
69184   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
69185   jresult = (int)result;
69186   return jresult;
69187 }
69188
69189
69190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
69191   int jresult ;
69192   int result;
69193
69194   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
69195   jresult = (int)result;
69196   return jresult;
69197 }
69198
69199
69200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
69201   int jresult ;
69202   int result;
69203
69204   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
69205   jresult = (int)result;
69206   return jresult;
69207 }
69208
69209
69210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
69211   int jresult ;
69212   int result;
69213
69214   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
69215   jresult = (int)result;
69216   return jresult;
69217 }
69218
69219
69220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
69221   int jresult ;
69222   int result;
69223
69224   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
69225   jresult = (int)result;
69226   return jresult;
69227 }
69228
69229
69230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
69231   int jresult ;
69232   int result;
69233
69234   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
69235   jresult = (int)result;
69236   return jresult;
69237 }
69238
69239
69240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
69241   int jresult ;
69242   int result;
69243
69244   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
69245   jresult = (int)result;
69246   return jresult;
69247 }
69248
69249
69250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
69251   void * jresult ;
69252   Dali::Toolkit::ScrollView::Property *result = 0 ;
69253
69254   {
69255     try {
69256       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
69257     } catch (std::out_of_range& e) {
69258       {
69259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69260       };
69261     } catch (std::exception& e) {
69262       {
69263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69264       };
69265     } catch (...) {
69266       {
69267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69268       };
69269     }
69270   }
69271   jresult = (void *)result;
69272   return jresult;
69273 }
69274
69275
69276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
69277   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
69278
69279   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
69280   {
69281     try {
69282       delete arg1;
69283     } catch (std::out_of_range& e) {
69284       {
69285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69286       };
69287     } catch (std::exception& e) {
69288       {
69289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69290       };
69291     } catch (...) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69294       };
69295     }
69296   }
69297 }
69298
69299
69300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
69301   void * jresult ;
69302   Dali::Toolkit::ScrollView *result = 0 ;
69303
69304   {
69305     try {
69306       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
69307     } catch (std::out_of_range& e) {
69308       {
69309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69310       };
69311     } catch (std::exception& e) {
69312       {
69313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69314       };
69315     } catch (...) {
69316       {
69317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69318       };
69319     }
69320   }
69321   jresult = (void *)result;
69322   return jresult;
69323 }
69324
69325
69326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
69327   void * jresult ;
69328   Dali::Toolkit::ScrollView *arg1 = 0 ;
69329   Dali::Toolkit::ScrollView *result = 0 ;
69330
69331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69332   if (!arg1) {
69333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69334     return 0;
69335   }
69336   {
69337     try {
69338       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
69339     } catch (std::out_of_range& e) {
69340       {
69341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69342       };
69343     } catch (std::exception& e) {
69344       {
69345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69346       };
69347     } catch (...) {
69348       {
69349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69350       };
69351     }
69352   }
69353   jresult = (void *)result;
69354   return jresult;
69355 }
69356
69357
69358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
69359   void * jresult ;
69360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69361   Dali::Toolkit::ScrollView *arg2 = 0 ;
69362   Dali::Toolkit::ScrollView *result = 0 ;
69363
69364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69365   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
69366   if (!arg2) {
69367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
69368     return 0;
69369   }
69370   {
69371     try {
69372       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
69373     } catch (std::out_of_range& e) {
69374       {
69375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69376       };
69377     } catch (std::exception& e) {
69378       {
69379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (...) {
69382       {
69383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69384       };
69385     }
69386   }
69387   jresult = (void *)result;
69388   return jresult;
69389 }
69390
69391
69392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
69393   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69394
69395   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69396   {
69397     try {
69398       delete arg1;
69399     } catch (std::out_of_range& e) {
69400       {
69401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69402       };
69403     } catch (std::exception& e) {
69404       {
69405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69406       };
69407     } catch (...) {
69408       {
69409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69410       };
69411     }
69412   }
69413 }
69414
69415
69416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
69417   void * jresult ;
69418   Dali::Toolkit::ScrollView result;
69419
69420   {
69421     try {
69422       result = Dali::Toolkit::ScrollView::New();
69423     } catch (std::out_of_range& e) {
69424       {
69425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69426       };
69427     } catch (std::exception& e) {
69428       {
69429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69430       };
69431     } catch (...) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69434       };
69435     }
69436   }
69437   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69438   return jresult;
69439 }
69440
69441
69442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
69443   void * jresult ;
69444   Dali::BaseHandle arg1 ;
69445   Dali::BaseHandle *argp1 ;
69446   Dali::Toolkit::ScrollView result;
69447
69448   argp1 = (Dali::BaseHandle *)jarg1;
69449   if (!argp1) {
69450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69451     return 0;
69452   }
69453   arg1 = *argp1;
69454   {
69455     try {
69456       result = Dali::Toolkit::ScrollView::DownCast(arg1);
69457     } catch (std::out_of_range& e) {
69458       {
69459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69460       };
69461     } catch (std::exception& e) {
69462       {
69463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69464       };
69465     } catch (...) {
69466       {
69467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69468       };
69469     }
69470   }
69471   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
69472   return jresult;
69473 }
69474
69475
69476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
69477   void * jresult ;
69478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69479   Dali::AlphaFunction result;
69480
69481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69482   {
69483     try {
69484       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
69485     } catch (std::out_of_range& e) {
69486       {
69487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69488       };
69489     } catch (std::exception& e) {
69490       {
69491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (...) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69496       };
69497     }
69498   }
69499   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69500   return jresult;
69501 }
69502
69503
69504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
69505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69506   Dali::AlphaFunction arg2 ;
69507   Dali::AlphaFunction *argp2 ;
69508
69509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69510   argp2 = (Dali::AlphaFunction *)jarg2;
69511   if (!argp2) {
69512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69513     return ;
69514   }
69515   arg2 = *argp2;
69516   {
69517     try {
69518       (arg1)->SetScrollSnapAlphaFunction(arg2);
69519     } catch (std::out_of_range& e) {
69520       {
69521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69522       };
69523     } catch (std::exception& e) {
69524       {
69525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69526       };
69527     } catch (...) {
69528       {
69529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69530       };
69531     }
69532   }
69533 }
69534
69535
69536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
69537   void * jresult ;
69538   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69539   Dali::AlphaFunction result;
69540
69541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69542   {
69543     try {
69544       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
69545     } catch (std::out_of_range& e) {
69546       {
69547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69548       };
69549     } catch (std::exception& e) {
69550       {
69551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69552       };
69553     } catch (...) {
69554       {
69555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69556       };
69557     }
69558   }
69559   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
69560   return jresult;
69561 }
69562
69563
69564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
69565   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69566   Dali::AlphaFunction arg2 ;
69567   Dali::AlphaFunction *argp2 ;
69568
69569   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69570   argp2 = (Dali::AlphaFunction *)jarg2;
69571   if (!argp2) {
69572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69573     return ;
69574   }
69575   arg2 = *argp2;
69576   {
69577     try {
69578       (arg1)->SetScrollFlickAlphaFunction(arg2);
69579     } catch (std::out_of_range& e) {
69580       {
69581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69582       };
69583     } catch (std::exception& e) {
69584       {
69585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69586       };
69587     } catch (...) {
69588       {
69589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69590       };
69591     }
69592   }
69593 }
69594
69595
69596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
69597   float jresult ;
69598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69599   float result;
69600
69601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69602   {
69603     try {
69604       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
69605     } catch (std::out_of_range& e) {
69606       {
69607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (std::exception& e) {
69610       {
69611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69616       };
69617     }
69618   }
69619   jresult = result;
69620   return jresult;
69621 }
69622
69623
69624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
69625   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69626   float arg2 ;
69627
69628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69629   arg2 = (float)jarg2;
69630   {
69631     try {
69632       (arg1)->SetScrollSnapDuration(arg2);
69633     } catch (std::out_of_range& e) {
69634       {
69635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69636       };
69637     } catch (std::exception& e) {
69638       {
69639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69640       };
69641     } catch (...) {
69642       {
69643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69644       };
69645     }
69646   }
69647 }
69648
69649
69650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
69651   float jresult ;
69652   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69653   float result;
69654
69655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69656   {
69657     try {
69658       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
69659     } catch (std::out_of_range& e) {
69660       {
69661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69662       };
69663     } catch (std::exception& e) {
69664       {
69665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69666       };
69667     } catch (...) {
69668       {
69669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69670       };
69671     }
69672   }
69673   jresult = result;
69674   return jresult;
69675 }
69676
69677
69678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
69679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69680   float arg2 ;
69681
69682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69683   arg2 = (float)jarg2;
69684   {
69685     try {
69686       (arg1)->SetScrollFlickDuration(arg2);
69687     } catch (std::out_of_range& e) {
69688       {
69689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69690       };
69691     } catch (std::exception& e) {
69692       {
69693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69694       };
69695     } catch (...) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69698       };
69699     }
69700   }
69701 }
69702
69703
69704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
69705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69706   Dali::Toolkit::RulerPtr arg2 ;
69707   Dali::Toolkit::RulerPtr *argp2 ;
69708
69709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69710   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69711   if (!argp2) {
69712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69713     return ;
69714   }
69715   arg2 = *argp2;
69716   {
69717     try {
69718       (arg1)->SetRulerX(arg2);
69719     } catch (std::out_of_range& e) {
69720       {
69721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69722       };
69723     } catch (std::exception& e) {
69724       {
69725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69726       };
69727     } catch (...) {
69728       {
69729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69730       };
69731     }
69732   }
69733 }
69734
69735
69736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
69737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69738   Dali::Toolkit::RulerPtr arg2 ;
69739   Dali::Toolkit::RulerPtr *argp2 ;
69740
69741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69742   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
69743   if (!argp2) {
69744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
69745     return ;
69746   }
69747   arg2 = *argp2;
69748   {
69749     try {
69750       (arg1)->SetRulerY(arg2);
69751     } catch (std::out_of_range& e) {
69752       {
69753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69754       };
69755     } catch (std::exception& e) {
69756       {
69757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69758       };
69759     } catch (...) {
69760       {
69761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69762       };
69763     }
69764   }
69765 }
69766
69767
69768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
69769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69770   bool arg2 ;
69771
69772   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69773   arg2 = jarg2 ? true : false;
69774   {
69775     try {
69776       (arg1)->SetScrollSensitive(arg2);
69777     } catch (std::out_of_range& e) {
69778       {
69779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69780       };
69781     } catch (std::exception& e) {
69782       {
69783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69788       };
69789     }
69790   }
69791 }
69792
69793
69794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
69795   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69796   float arg2 ;
69797   float arg3 ;
69798
69799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69800   arg2 = (float)jarg2;
69801   arg3 = (float)jarg3;
69802   {
69803     try {
69804       (arg1)->SetMaxOvershoot(arg2,arg3);
69805     } catch (std::out_of_range& e) {
69806       {
69807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69808       };
69809     } catch (std::exception& e) {
69810       {
69811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69816       };
69817     }
69818   }
69819 }
69820
69821
69822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
69823   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69824   Dali::AlphaFunction arg2 ;
69825   Dali::AlphaFunction *argp2 ;
69826
69827   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69828   argp2 = (Dali::AlphaFunction *)jarg2;
69829   if (!argp2) {
69830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
69831     return ;
69832   }
69833   arg2 = *argp2;
69834   {
69835     try {
69836       (arg1)->SetSnapOvershootAlphaFunction(arg2);
69837     } catch (std::out_of_range& e) {
69838       {
69839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69840       };
69841     } catch (std::exception& e) {
69842       {
69843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69844       };
69845     } catch (...) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69848       };
69849     }
69850   }
69851 }
69852
69853
69854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
69855   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69856   float arg2 ;
69857
69858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69859   arg2 = (float)jarg2;
69860   {
69861     try {
69862       (arg1)->SetSnapOvershootDuration(arg2);
69863     } catch (std::out_of_range& e) {
69864       {
69865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69866       };
69867     } catch (std::exception& e) {
69868       {
69869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69870       };
69871     } catch (...) {
69872       {
69873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69874       };
69875     }
69876   }
69877 }
69878
69879
69880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
69881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69882   bool arg2 ;
69883
69884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69885   arg2 = jarg2 ? true : false;
69886   {
69887     try {
69888       (arg1)->SetActorAutoSnap(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 void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
69907   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69908   bool arg2 ;
69909
69910   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69911   arg2 = jarg2 ? true : false;
69912   {
69913     try {
69914       (arg1)->SetWrapMode(arg2);
69915     } catch (std::out_of_range& e) {
69916       {
69917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69918       };
69919     } catch (std::exception& e) {
69920       {
69921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69922       };
69923     } catch (...) {
69924       {
69925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69926       };
69927     }
69928   }
69929 }
69930
69931
69932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
69933   int jresult ;
69934   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69935   int result;
69936
69937   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69938   {
69939     try {
69940       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
69941     } catch (std::out_of_range& e) {
69942       {
69943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69944       };
69945     } catch (std::exception& e) {
69946       {
69947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69948       };
69949     } catch (...) {
69950       {
69951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69952       };
69953     }
69954   }
69955   jresult = result;
69956   return jresult;
69957 }
69958
69959
69960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
69961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69962   int arg2 ;
69963
69964   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69965   arg2 = (int)jarg2;
69966   {
69967     try {
69968       (arg1)->SetScrollUpdateDistance(arg2);
69969     } catch (std::out_of_range& e) {
69970       {
69971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69972       };
69973     } catch (std::exception& e) {
69974       {
69975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69976       };
69977     } catch (...) {
69978       {
69979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69980       };
69981     }
69982   }
69983 }
69984
69985
69986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
69987   unsigned int jresult ;
69988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
69989   bool result;
69990
69991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
69992   {
69993     try {
69994       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
69995     } catch (std::out_of_range& e) {
69996       {
69997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69998       };
69999     } catch (std::exception& e) {
70000       {
70001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70002       };
70003     } catch (...) {
70004       {
70005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70006       };
70007     }
70008   }
70009   jresult = result;
70010   return jresult;
70011 }
70012
70013
70014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
70015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70016   bool arg2 ;
70017
70018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70019   arg2 = jarg2 ? true : false;
70020   {
70021     try {
70022       (arg1)->SetAxisAutoLock(arg2);
70023     } catch (std::out_of_range& e) {
70024       {
70025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70026       };
70027     } catch (std::exception& e) {
70028       {
70029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70030       };
70031     } catch (...) {
70032       {
70033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70034       };
70035     }
70036   }
70037 }
70038
70039
70040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
70041   float jresult ;
70042   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70043   float result;
70044
70045   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70046   {
70047     try {
70048       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70060       };
70061     }
70062   }
70063   jresult = result;
70064   return jresult;
70065 }
70066
70067
70068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
70069   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70070   float arg2 ;
70071
70072   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70073   arg2 = (float)jarg2;
70074   {
70075     try {
70076       (arg1)->SetAxisAutoLockGradient(arg2);
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70084       };
70085     } catch (...) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70088       };
70089     }
70090   }
70091 }
70092
70093
70094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
70095   float jresult ;
70096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70097   float result;
70098
70099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70100   {
70101     try {
70102       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
70103     } catch (std::out_of_range& e) {
70104       {
70105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70106       };
70107     } catch (std::exception& e) {
70108       {
70109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (...) {
70112       {
70113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70114       };
70115     }
70116   }
70117   jresult = result;
70118   return jresult;
70119 }
70120
70121
70122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
70123   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70124   float arg2 ;
70125
70126   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70127   arg2 = (float)jarg2;
70128   {
70129     try {
70130       (arg1)->SetFrictionCoefficient(arg2);
70131     } catch (std::out_of_range& e) {
70132       {
70133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70134       };
70135     } catch (std::exception& e) {
70136       {
70137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70138       };
70139     } catch (...) {
70140       {
70141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70142       };
70143     }
70144   }
70145 }
70146
70147
70148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
70149   float jresult ;
70150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70151   float result;
70152
70153   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70154   {
70155     try {
70156       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
70157     } catch (std::out_of_range& e) {
70158       {
70159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70160       };
70161     } catch (std::exception& e) {
70162       {
70163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70164       };
70165     } catch (...) {
70166       {
70167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70168       };
70169     }
70170   }
70171   jresult = result;
70172   return jresult;
70173 }
70174
70175
70176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
70177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70178   float arg2 ;
70179
70180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70181   arg2 = (float)jarg2;
70182   {
70183     try {
70184       (arg1)->SetFlickSpeedCoefficient(arg2);
70185     } catch (std::out_of_range& e) {
70186       {
70187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70188       };
70189     } catch (std::exception& e) {
70190       {
70191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70192       };
70193     } catch (...) {
70194       {
70195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70196       };
70197     }
70198   }
70199 }
70200
70201
70202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
70203   void * jresult ;
70204   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70205   Dali::Vector2 result;
70206
70207   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70208   {
70209     try {
70210       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
70211     } catch (std::out_of_range& e) {
70212       {
70213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (std::exception& e) {
70216       {
70217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70226   return jresult;
70227 }
70228
70229
70230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
70231   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70232   Dali::Vector2 *arg2 = 0 ;
70233
70234   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70235   arg2 = (Dali::Vector2 *)jarg2;
70236   if (!arg2) {
70237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70238     return ;
70239   }
70240   {
70241     try {
70242       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
70243     } catch (std::out_of_range& e) {
70244       {
70245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70246       };
70247     } catch (std::exception& e) {
70248       {
70249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70250       };
70251     } catch (...) {
70252       {
70253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70254       };
70255     }
70256   }
70257 }
70258
70259
70260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
70261   float jresult ;
70262   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70263   float result;
70264
70265   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70266   {
70267     try {
70268       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
70269     } catch (std::out_of_range& e) {
70270       {
70271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70272       };
70273     } catch (std::exception& e) {
70274       {
70275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (...) {
70278       {
70279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70280       };
70281     }
70282   }
70283   jresult = result;
70284   return jresult;
70285 }
70286
70287
70288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
70289   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70290   float arg2 ;
70291
70292   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70293   arg2 = (float)jarg2;
70294   {
70295     try {
70296       (arg1)->SetMinimumSpeedForFlick(arg2);
70297     } catch (std::out_of_range& e) {
70298       {
70299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70300       };
70301     } catch (std::exception& e) {
70302       {
70303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70304       };
70305     } catch (...) {
70306       {
70307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70308       };
70309     }
70310   }
70311 }
70312
70313
70314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
70315   float jresult ;
70316   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70317   float result;
70318
70319   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70320   {
70321     try {
70322       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
70323     } catch (std::out_of_range& e) {
70324       {
70325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70326       };
70327     } catch (std::exception& e) {
70328       {
70329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70330       };
70331     } catch (...) {
70332       {
70333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70334       };
70335     }
70336   }
70337   jresult = result;
70338   return jresult;
70339 }
70340
70341
70342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
70343   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70344   float arg2 ;
70345
70346   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70347   arg2 = (float)jarg2;
70348   {
70349     try {
70350       (arg1)->SetMaxFlickSpeed(arg2);
70351     } catch (std::out_of_range& e) {
70352       {
70353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70354       };
70355     } catch (std::exception& e) {
70356       {
70357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70358       };
70359     } catch (...) {
70360       {
70361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70362       };
70363     }
70364   }
70365 }
70366
70367
70368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
70369   void * jresult ;
70370   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70371   Dali::Vector2 result;
70372
70373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70374   {
70375     try {
70376       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
70377     } catch (std::out_of_range& e) {
70378       {
70379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70380       };
70381     } catch (std::exception& e) {
70382       {
70383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70384       };
70385     } catch (...) {
70386       {
70387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70388       };
70389     }
70390   }
70391   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70392   return jresult;
70393 }
70394
70395
70396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
70397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70398   Dali::Vector2 arg2 ;
70399   Dali::Vector2 *argp2 ;
70400
70401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70402   argp2 = (Dali::Vector2 *)jarg2;
70403   if (!argp2) {
70404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
70405     return ;
70406   }
70407   arg2 = *argp2;
70408   {
70409     try {
70410       (arg1)->SetWheelScrollDistanceStep(arg2);
70411     } catch (std::out_of_range& e) {
70412       {
70413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70414       };
70415     } catch (std::exception& e) {
70416       {
70417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70418       };
70419     } catch (...) {
70420       {
70421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70422       };
70423     }
70424   }
70425 }
70426
70427
70428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
70429   void * jresult ;
70430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70431   Dali::Vector2 result;
70432
70433   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70434   {
70435     try {
70436       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
70437     } catch (std::out_of_range& e) {
70438       {
70439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70440       };
70441     } catch (std::exception& e) {
70442       {
70443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70444       };
70445     } catch (...) {
70446       {
70447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70448       };
70449     }
70450   }
70451   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
70452   return jresult;
70453 }
70454
70455
70456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
70457   unsigned int jresult ;
70458   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70459   unsigned int result;
70460
70461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70462   {
70463     try {
70464       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
70465     } catch (std::out_of_range& e) {
70466       {
70467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70468       };
70469     } catch (std::exception& e) {
70470       {
70471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70472       };
70473     } catch (...) {
70474       {
70475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70476       };
70477     }
70478   }
70479   jresult = result;
70480   return jresult;
70481 }
70482
70483
70484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
70485   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70486   Dali::Vector2 *arg2 = 0 ;
70487
70488   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70489   arg2 = (Dali::Vector2 *)jarg2;
70490   if (!arg2) {
70491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70492     return ;
70493   }
70494   {
70495     try {
70496       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
70497     } catch (std::out_of_range& e) {
70498       {
70499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70500       };
70501     } catch (std::exception& e) {
70502       {
70503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70504       };
70505     } catch (...) {
70506       {
70507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70508       };
70509     }
70510   }
70511 }
70512
70513
70514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
70515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70516   Dali::Vector2 *arg2 = 0 ;
70517   float arg3 ;
70518
70519   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70520   arg2 = (Dali::Vector2 *)jarg2;
70521   if (!arg2) {
70522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70523     return ;
70524   }
70525   arg3 = (float)jarg3;
70526   {
70527     try {
70528       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
70529     } catch (std::out_of_range& e) {
70530       {
70531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70532       };
70533     } catch (std::exception& e) {
70534       {
70535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70536       };
70537     } catch (...) {
70538       {
70539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70540       };
70541     }
70542   }
70543 }
70544
70545
70546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
70547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70548   Dali::Vector2 *arg2 = 0 ;
70549   float arg3 ;
70550   Dali::AlphaFunction arg4 ;
70551   Dali::AlphaFunction *argp4 ;
70552
70553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70554   arg2 = (Dali::Vector2 *)jarg2;
70555   if (!arg2) {
70556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70557     return ;
70558   }
70559   arg3 = (float)jarg3;
70560   argp4 = (Dali::AlphaFunction *)jarg4;
70561   if (!argp4) {
70562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70563     return ;
70564   }
70565   arg4 = *argp4;
70566   {
70567     try {
70568       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
70569     } catch (std::out_of_range& e) {
70570       {
70571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (std::exception& e) {
70574       {
70575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (...) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70580       };
70581     }
70582   }
70583 }
70584
70585
70586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
70587   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70588   Dali::Vector2 *arg2 = 0 ;
70589   float arg3 ;
70590   Dali::Toolkit::DirectionBias arg4 ;
70591   Dali::Toolkit::DirectionBias arg5 ;
70592
70593   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70594   arg2 = (Dali::Vector2 *)jarg2;
70595   if (!arg2) {
70596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70597     return ;
70598   }
70599   arg3 = (float)jarg3;
70600   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70601   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70602   {
70603     try {
70604       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
70605     } catch (std::out_of_range& e) {
70606       {
70607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70608       };
70609     } catch (std::exception& e) {
70610       {
70611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70612       };
70613     } catch (...) {
70614       {
70615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70616       };
70617     }
70618   }
70619 }
70620
70621
70622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
70623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70624   Dali::Vector2 *arg2 = 0 ;
70625   float arg3 ;
70626   Dali::AlphaFunction arg4 ;
70627   Dali::Toolkit::DirectionBias arg5 ;
70628   Dali::Toolkit::DirectionBias arg6 ;
70629   Dali::AlphaFunction *argp4 ;
70630
70631   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70632   arg2 = (Dali::Vector2 *)jarg2;
70633   if (!arg2) {
70634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
70635     return ;
70636   }
70637   arg3 = (float)jarg3;
70638   argp4 = (Dali::AlphaFunction *)jarg4;
70639   if (!argp4) {
70640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
70641     return ;
70642   }
70643   arg4 = *argp4;
70644   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
70645   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
70646   {
70647     try {
70648       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
70649     } catch (std::out_of_range& e) {
70650       {
70651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70652       };
70653     } catch (std::exception& e) {
70654       {
70655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70656       };
70657     } catch (...) {
70658       {
70659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70660       };
70661     }
70662   }
70663 }
70664
70665
70666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
70667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70668   unsigned int arg2 ;
70669
70670   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70671   arg2 = (unsigned int)jarg2;
70672   {
70673     try {
70674       (arg1)->ScrollTo(arg2);
70675     } catch (std::out_of_range& e) {
70676       {
70677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70678       };
70679     } catch (std::exception& e) {
70680       {
70681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70682       };
70683     } catch (...) {
70684       {
70685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70686       };
70687     }
70688   }
70689 }
70690
70691
70692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
70693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70694   unsigned int arg2 ;
70695   float arg3 ;
70696
70697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70698   arg2 = (unsigned int)jarg2;
70699   arg3 = (float)jarg3;
70700   {
70701     try {
70702       (arg1)->ScrollTo(arg2,arg3);
70703     } catch (std::out_of_range& e) {
70704       {
70705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70706       };
70707     } catch (std::exception& e) {
70708       {
70709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70714       };
70715     }
70716   }
70717 }
70718
70719
70720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
70721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70722   unsigned int arg2 ;
70723   float arg3 ;
70724   Dali::Toolkit::DirectionBias arg4 ;
70725
70726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70727   arg2 = (unsigned int)jarg2;
70728   arg3 = (float)jarg3;
70729   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
70730   {
70731     try {
70732       (arg1)->ScrollTo(arg2,arg3,arg4);
70733     } catch (std::out_of_range& e) {
70734       {
70735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70736       };
70737     } catch (std::exception& e) {
70738       {
70739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70740       };
70741     } catch (...) {
70742       {
70743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70744       };
70745     }
70746   }
70747 }
70748
70749
70750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
70751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70752   Dali::Actor *arg2 = 0 ;
70753
70754   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70755   arg2 = (Dali::Actor *)jarg2;
70756   if (!arg2) {
70757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70758     return ;
70759   }
70760   {
70761     try {
70762       (arg1)->ScrollTo(*arg2);
70763     } catch (std::out_of_range& e) {
70764       {
70765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70766       };
70767     } catch (std::exception& e) {
70768       {
70769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70770       };
70771     } catch (...) {
70772       {
70773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70774       };
70775     }
70776   }
70777 }
70778
70779
70780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
70781   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70782   Dali::Actor *arg2 = 0 ;
70783   float arg3 ;
70784
70785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70786   arg2 = (Dali::Actor *)jarg2;
70787   if (!arg2) {
70788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70789     return ;
70790   }
70791   arg3 = (float)jarg3;
70792   {
70793     try {
70794       (arg1)->ScrollTo(*arg2,arg3);
70795     } catch (std::out_of_range& e) {
70796       {
70797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70798       };
70799     } catch (std::exception& e) {
70800       {
70801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70802       };
70803     } catch (...) {
70804       {
70805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70806       };
70807     }
70808   }
70809 }
70810
70811
70812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
70813   unsigned int jresult ;
70814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70815   bool result;
70816
70817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70818   {
70819     try {
70820       result = (bool)(arg1)->ScrollToSnapPoint();
70821     } catch (std::out_of_range& e) {
70822       {
70823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70824       };
70825     } catch (std::exception& e) {
70826       {
70827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70828       };
70829     } catch (...) {
70830       {
70831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70832       };
70833     }
70834   }
70835   jresult = result;
70836   return jresult;
70837 }
70838
70839
70840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
70841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70842   Dali::Constraint arg2 ;
70843   Dali::Constraint *argp2 ;
70844
70845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70846   argp2 = (Dali::Constraint *)jarg2;
70847   if (!argp2) {
70848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
70849     return ;
70850   }
70851   arg2 = *argp2;
70852   {
70853     try {
70854       (arg1)->ApplyConstraintToChildren(arg2);
70855     } catch (std::out_of_range& e) {
70856       {
70857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70858       };
70859     } catch (std::exception& e) {
70860       {
70861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70862       };
70863     } catch (...) {
70864       {
70865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70866       };
70867     }
70868   }
70869 }
70870
70871
70872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
70873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70874
70875   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70876   {
70877     try {
70878       (arg1)->RemoveConstraintsFromChildren();
70879     } catch (std::out_of_range& e) {
70880       {
70881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70882       };
70883     } catch (std::exception& e) {
70884       {
70885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70890       };
70891     }
70892   }
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
70897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70898   Dali::Toolkit::ScrollViewEffect arg2 ;
70899   Dali::Toolkit::ScrollViewEffect *argp2 ;
70900
70901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70902   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70903   if (!argp2) {
70904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70905     return ;
70906   }
70907   arg2 = *argp2;
70908   {
70909     try {
70910       (arg1)->ApplyEffect(arg2);
70911     } catch (std::out_of_range& e) {
70912       {
70913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70914       };
70915     } catch (std::exception& e) {
70916       {
70917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70918       };
70919     } catch (...) {
70920       {
70921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70922       };
70923     }
70924   }
70925 }
70926
70927
70928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
70929   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70930   Dali::Toolkit::ScrollViewEffect arg2 ;
70931   Dali::Toolkit::ScrollViewEffect *argp2 ;
70932
70933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70934   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
70935   if (!argp2) {
70936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
70937     return ;
70938   }
70939   arg2 = *argp2;
70940   {
70941     try {
70942       (arg1)->RemoveEffect(arg2);
70943     } catch (std::out_of_range& e) {
70944       {
70945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70946       };
70947     } catch (std::exception& e) {
70948       {
70949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70950       };
70951     } catch (...) {
70952       {
70953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70954       };
70955     }
70956   }
70957 }
70958
70959
70960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
70961   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70962
70963   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70964   {
70965     try {
70966       (arg1)->RemoveAllEffects();
70967     } catch (std::out_of_range& e) {
70968       {
70969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70970       };
70971     } catch (std::exception& e) {
70972       {
70973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70974       };
70975     } catch (...) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70978       };
70979     }
70980   }
70981 }
70982
70983
70984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
70985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
70986   Dali::Actor arg2 ;
70987   Dali::Actor *argp2 ;
70988
70989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
70990   argp2 = (Dali::Actor *)jarg2;
70991   if (!argp2) {
70992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70993     return ;
70994   }
70995   arg2 = *argp2;
70996   {
70997     try {
70998       (arg1)->BindActor(arg2);
70999     } catch (std::out_of_range& e) {
71000       {
71001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71002       };
71003     } catch (std::exception& e) {
71004       {
71005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71010       };
71011     }
71012   }
71013 }
71014
71015
71016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
71017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71018   Dali::Actor arg2 ;
71019   Dali::Actor *argp2 ;
71020
71021   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71022   argp2 = (Dali::Actor *)jarg2;
71023   if (!argp2) {
71024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71025     return ;
71026   }
71027   arg2 = *argp2;
71028   {
71029     try {
71030       (arg1)->UnbindActor(arg2);
71031     } catch (std::out_of_range& e) {
71032       {
71033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71034       };
71035     } catch (std::exception& e) {
71036       {
71037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71038       };
71039     } catch (...) {
71040       {
71041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71042       };
71043     }
71044   }
71045 }
71046
71047
71048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
71049   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71050   Dali::Radian arg2 ;
71051   Dali::Radian arg3 ;
71052   Dali::Radian *argp2 ;
71053   Dali::Radian *argp3 ;
71054
71055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71056   argp2 = (Dali::Radian *)jarg2;
71057   if (!argp2) {
71058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71059     return ;
71060   }
71061   arg2 = *argp2;
71062   argp3 = (Dali::Radian *)jarg3;
71063   if (!argp3) {
71064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71065     return ;
71066   }
71067   arg3 = *argp3;
71068   {
71069     try {
71070       (arg1)->SetScrollingDirection(arg2,arg3);
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71082       };
71083     }
71084   }
71085 }
71086
71087
71088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
71089   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71090   Dali::Radian arg2 ;
71091   Dali::Radian *argp2 ;
71092
71093   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71094   argp2 = (Dali::Radian *)jarg2;
71095   if (!argp2) {
71096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71097     return ;
71098   }
71099   arg2 = *argp2;
71100   {
71101     try {
71102       (arg1)->SetScrollingDirection(arg2);
71103     } catch (std::out_of_range& e) {
71104       {
71105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71106       };
71107     } catch (std::exception& e) {
71108       {
71109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71110       };
71111     } catch (...) {
71112       {
71113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71114       };
71115     }
71116   }
71117 }
71118
71119
71120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
71121   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71122   Dali::Radian arg2 ;
71123   Dali::Radian *argp2 ;
71124
71125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71126   argp2 = (Dali::Radian *)jarg2;
71127   if (!argp2) {
71128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
71129     return ;
71130   }
71131   arg2 = *argp2;
71132   {
71133     try {
71134       (arg1)->RemoveScrollingDirection(arg2);
71135     } catch (std::out_of_range& e) {
71136       {
71137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71138       };
71139     } catch (std::exception& e) {
71140       {
71141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71142       };
71143     } catch (...) {
71144       {
71145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71146       };
71147     }
71148   }
71149 }
71150
71151
71152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
71153   void * jresult ;
71154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71155   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
71156
71157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71158   {
71159     try {
71160       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
71161     } catch (std::out_of_range& e) {
71162       {
71163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71164       };
71165     } catch (std::exception& e) {
71166       {
71167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71168       };
71169     } catch (...) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71172       };
71173     }
71174   }
71175   jresult = (void *)result;
71176   return jresult;
71177 }
71178
71179
71180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
71181   int jresult ;
71182   int result;
71183
71184   result = (int)Dali::Toolkit::TableView::Property::ROWS;
71185   jresult = (int)result;
71186   return jresult;
71187 }
71188
71189
71190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
71191   int jresult ;
71192   int result;
71193
71194   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
71195   jresult = (int)result;
71196   return jresult;
71197 }
71198
71199
71200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
71201   int jresult ;
71202   int result;
71203
71204   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
71205   jresult = (int)result;
71206   return jresult;
71207 }
71208
71209
71210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
71211   int jresult ;
71212   int result;
71213
71214   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
71215   jresult = (int)result;
71216   return jresult;
71217 }
71218
71219
71220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
71221   int jresult ;
71222   int result;
71223
71224   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
71225   jresult = (int)result;
71226   return jresult;
71227 }
71228
71229
71230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
71231   void * jresult ;
71232   Dali::Toolkit::TableView::Property *result = 0 ;
71233
71234   {
71235     try {
71236       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
71237     } catch (std::out_of_range& e) {
71238       {
71239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71240       };
71241     } catch (std::exception& e) {
71242       {
71243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71244       };
71245     } catch (...) {
71246       {
71247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71248       };
71249     }
71250   }
71251   jresult = (void *)result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
71257   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
71258
71259   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
71260   {
71261     try {
71262       delete arg1;
71263     } catch (std::out_of_range& e) {
71264       {
71265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71266       };
71267     } catch (std::exception& e) {
71268       {
71269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71270       };
71271     } catch (...) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71274       };
71275     }
71276   }
71277 }
71278
71279
71280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
71281   int jresult ;
71282   int result;
71283
71284   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
71285   jresult = (int)result;
71286   return jresult;
71287 }
71288
71289
71290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
71291   int jresult ;
71292   int result;
71293
71294   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
71295   jresult = (int)result;
71296   return jresult;
71297 }
71298
71299
71300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
71301   int jresult ;
71302   int result;
71303
71304   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
71305   jresult = (int)result;
71306   return jresult;
71307 }
71308
71309
71310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
71311   int jresult ;
71312   int result;
71313
71314   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
71315   jresult = (int)result;
71316   return jresult;
71317 }
71318
71319
71320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
71321   int jresult ;
71322   int result;
71323
71324   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
71325   jresult = (int)result;
71326   return jresult;
71327 }
71328
71329
71330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
71331   void * jresult ;
71332   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
71333
71334   {
71335     try {
71336       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
71337     } catch (std::out_of_range& e) {
71338       {
71339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71340       };
71341     } catch (std::exception& e) {
71342       {
71343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71344       };
71345     } catch (...) {
71346       {
71347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71348       };
71349     }
71350   }
71351   jresult = (void *)result;
71352   return jresult;
71353 }
71354
71355
71356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
71357   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
71358
71359   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
71360   {
71361     try {
71362       delete arg1;
71363     } catch (std::out_of_range& e) {
71364       {
71365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71366       };
71367     } catch (std::exception& e) {
71368       {
71369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71370       };
71371     } catch (...) {
71372       {
71373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71374       };
71375     }
71376   }
71377 }
71378
71379
71380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
71381   void * jresult ;
71382   unsigned int arg1 ;
71383   unsigned int arg2 ;
71384   unsigned int arg3 ;
71385   unsigned int arg4 ;
71386   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71387
71388   arg1 = (unsigned int)jarg1;
71389   arg2 = (unsigned int)jarg2;
71390   arg3 = (unsigned int)jarg3;
71391   arg4 = (unsigned int)jarg4;
71392   {
71393     try {
71394       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
71395     } catch (std::out_of_range& e) {
71396       {
71397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71398       };
71399     } catch (std::exception& e) {
71400       {
71401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71406       };
71407     }
71408   }
71409   jresult = (void *)result;
71410   return jresult;
71411 }
71412
71413
71414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
71415   void * jresult ;
71416   unsigned int arg1 ;
71417   unsigned int arg2 ;
71418   unsigned int arg3 ;
71419   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71420
71421   arg1 = (unsigned int)jarg1;
71422   arg2 = (unsigned int)jarg2;
71423   arg3 = (unsigned int)jarg3;
71424   {
71425     try {
71426       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
71427     } catch (std::out_of_range& e) {
71428       {
71429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71430       };
71431     } catch (std::exception& e) {
71432       {
71433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71438       };
71439     }
71440   }
71441   jresult = (void *)result;
71442   return jresult;
71443 }
71444
71445
71446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
71447   void * jresult ;
71448   unsigned int arg1 ;
71449   unsigned int arg2 ;
71450   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71451
71452   arg1 = (unsigned int)jarg1;
71453   arg2 = (unsigned int)jarg2;
71454   {
71455     try {
71456       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
71457     } catch (std::out_of_range& e) {
71458       {
71459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71460       };
71461     } catch (std::exception& e) {
71462       {
71463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71464       };
71465     } catch (...) {
71466       {
71467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71468       };
71469     }
71470   }
71471   jresult = (void *)result;
71472   return jresult;
71473 }
71474
71475
71476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
71477   void * jresult ;
71478   unsigned int arg1 ;
71479   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71480
71481   arg1 = (unsigned int)jarg1;
71482   {
71483     try {
71484       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
71485     } catch (std::out_of_range& e) {
71486       {
71487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71488       };
71489     } catch (std::exception& e) {
71490       {
71491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71492       };
71493     } catch (...) {
71494       {
71495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71496       };
71497     }
71498   }
71499   jresult = (void *)result;
71500   return jresult;
71501 }
71502
71503
71504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
71505   void * jresult ;
71506   Dali::Toolkit::TableView::CellPosition *result = 0 ;
71507
71508   {
71509     try {
71510       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
71511     } catch (std::out_of_range& e) {
71512       {
71513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71514       };
71515     } catch (std::exception& e) {
71516       {
71517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71518       };
71519     } catch (...) {
71520       {
71521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71522       };
71523     }
71524   }
71525   jresult = (void *)result;
71526   return jresult;
71527 }
71528
71529
71530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
71531   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71532   unsigned int arg2 ;
71533
71534   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71535   arg2 = (unsigned int)jarg2;
71536   if (arg1) (arg1)->rowIndex = arg2;
71537 }
71538
71539
71540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
71541   unsigned int jresult ;
71542   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71543   unsigned int result;
71544
71545   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71546   result = (unsigned int) ((arg1)->rowIndex);
71547   jresult = result;
71548   return jresult;
71549 }
71550
71551
71552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
71553   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71554   unsigned int arg2 ;
71555
71556   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71557   arg2 = (unsigned int)jarg2;
71558   if (arg1) (arg1)->columnIndex = arg2;
71559 }
71560
71561
71562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
71563   unsigned int jresult ;
71564   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71565   unsigned int result;
71566
71567   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71568   result = (unsigned int) ((arg1)->columnIndex);
71569   jresult = result;
71570   return jresult;
71571 }
71572
71573
71574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
71575   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71576   unsigned int arg2 ;
71577
71578   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71579   arg2 = (unsigned int)jarg2;
71580   if (arg1) (arg1)->rowSpan = arg2;
71581 }
71582
71583
71584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
71585   unsigned int jresult ;
71586   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71587   unsigned int result;
71588
71589   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71590   result = (unsigned int) ((arg1)->rowSpan);
71591   jresult = result;
71592   return jresult;
71593 }
71594
71595
71596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
71597   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71598   unsigned int arg2 ;
71599
71600   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71601   arg2 = (unsigned int)jarg2;
71602   if (arg1) (arg1)->columnSpan = arg2;
71603 }
71604
71605
71606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
71607   unsigned int jresult ;
71608   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71609   unsigned int result;
71610
71611   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71612   result = (unsigned int) ((arg1)->columnSpan);
71613   jresult = result;
71614   return jresult;
71615 }
71616
71617
71618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
71619   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
71620
71621   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
71622   {
71623     try {
71624       delete arg1;
71625     } catch (std::out_of_range& e) {
71626       {
71627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71628       };
71629     } catch (std::exception& e) {
71630       {
71631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71632       };
71633     } catch (...) {
71634       {
71635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71636       };
71637     }
71638   }
71639 }
71640
71641
71642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
71643   void * jresult ;
71644   Dali::Toolkit::TableView *result = 0 ;
71645
71646   {
71647     try {
71648       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
71649     } catch (std::out_of_range& e) {
71650       {
71651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71652       };
71653     } catch (std::exception& e) {
71654       {
71655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71656       };
71657     } catch (...) {
71658       {
71659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71660       };
71661     }
71662   }
71663   jresult = (void *)result;
71664   return jresult;
71665 }
71666
71667
71668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
71669   void * jresult ;
71670   Dali::Toolkit::TableView *arg1 = 0 ;
71671   Dali::Toolkit::TableView *result = 0 ;
71672
71673   arg1 = (Dali::Toolkit::TableView *)jarg1;
71674   if (!arg1) {
71675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71676     return 0;
71677   }
71678   {
71679     try {
71680       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
71681     } catch (std::out_of_range& e) {
71682       {
71683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71684       };
71685     } catch (std::exception& e) {
71686       {
71687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (...) {
71690       {
71691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71692       };
71693     }
71694   }
71695   jresult = (void *)result;
71696   return jresult;
71697 }
71698
71699
71700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
71701   void * jresult ;
71702   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71703   Dali::Toolkit::TableView *arg2 = 0 ;
71704   Dali::Toolkit::TableView *result = 0 ;
71705
71706   arg1 = (Dali::Toolkit::TableView *)jarg1;
71707   arg2 = (Dali::Toolkit::TableView *)jarg2;
71708   if (!arg2) {
71709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
71710     return 0;
71711   }
71712   {
71713     try {
71714       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
71715     } catch (std::out_of_range& e) {
71716       {
71717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71718       };
71719     } catch (std::exception& e) {
71720       {
71721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71722       };
71723     } catch (...) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71726       };
71727     }
71728   }
71729   jresult = (void *)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
71735   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71736
71737   arg1 = (Dali::Toolkit::TableView *)jarg1;
71738   {
71739     try {
71740       delete arg1;
71741     } catch (std::out_of_range& e) {
71742       {
71743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71744       };
71745     } catch (std::exception& e) {
71746       {
71747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71748       };
71749     } catch (...) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71752       };
71753     }
71754   }
71755 }
71756
71757
71758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
71759   void * jresult ;
71760   unsigned int arg1 ;
71761   unsigned int arg2 ;
71762   Dali::Toolkit::TableView result;
71763
71764   arg1 = (unsigned int)jarg1;
71765   arg2 = (unsigned int)jarg2;
71766   {
71767     try {
71768       result = Dali::Toolkit::TableView::New(arg1,arg2);
71769     } catch (std::out_of_range& e) {
71770       {
71771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71772       };
71773     } catch (std::exception& e) {
71774       {
71775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71776       };
71777     } catch (...) {
71778       {
71779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71780       };
71781     }
71782   }
71783   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71784   return jresult;
71785 }
71786
71787
71788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
71789   void * jresult ;
71790   Dali::BaseHandle arg1 ;
71791   Dali::BaseHandle *argp1 ;
71792   Dali::Toolkit::TableView result;
71793
71794   argp1 = (Dali::BaseHandle *)jarg1;
71795   if (!argp1) {
71796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71797     return 0;
71798   }
71799   arg1 = *argp1;
71800   {
71801     try {
71802       result = Dali::Toolkit::TableView::DownCast(arg1);
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71810       };
71811     } catch (...) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71814       };
71815     }
71816   }
71817   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
71818   return jresult;
71819 }
71820
71821
71822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
71823   unsigned int jresult ;
71824   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71825   Dali::Actor arg2 ;
71826   Dali::Toolkit::TableView::CellPosition arg3 ;
71827   Dali::Actor *argp2 ;
71828   Dali::Toolkit::TableView::CellPosition *argp3 ;
71829   bool result;
71830
71831   arg1 = (Dali::Toolkit::TableView *)jarg1;
71832   argp2 = (Dali::Actor *)jarg2;
71833   if (!argp2) {
71834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71835     return 0;
71836   }
71837   arg2 = *argp2;
71838   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71839   if (!argp3) {
71840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71841     return 0;
71842   }
71843   arg3 = *argp3;
71844   {
71845     try {
71846       result = (bool)(arg1)->AddChild(arg2,arg3);
71847     } catch (std::out_of_range& e) {
71848       {
71849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71850       };
71851     } catch (std::exception& e) {
71852       {
71853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71854       };
71855     } catch (...) {
71856       {
71857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71858       };
71859     }
71860   }
71861   jresult = result;
71862   return jresult;
71863 }
71864
71865
71866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
71867   void * jresult ;
71868   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71869   Dali::Toolkit::TableView::CellPosition arg2 ;
71870   Dali::Toolkit::TableView::CellPosition *argp2 ;
71871   Dali::Actor result;
71872
71873   arg1 = (Dali::Toolkit::TableView *)jarg1;
71874   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71875   if (!argp2) {
71876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71877     return 0;
71878   }
71879   arg2 = *argp2;
71880   {
71881     try {
71882       result = (arg1)->GetChildAt(arg2);
71883     } catch (std::out_of_range& e) {
71884       {
71885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71886       };
71887     } catch (std::exception& e) {
71888       {
71889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71894       };
71895     }
71896   }
71897   jresult = new Dali::Actor((const Dali::Actor &)result);
71898   return jresult;
71899 }
71900
71901
71902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
71903   void * jresult ;
71904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71905   Dali::Toolkit::TableView::CellPosition arg2 ;
71906   Dali::Toolkit::TableView::CellPosition *argp2 ;
71907   Dali::Actor result;
71908
71909   arg1 = (Dali::Toolkit::TableView *)jarg1;
71910   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
71911   if (!argp2) {
71912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
71913     return 0;
71914   }
71915   arg2 = *argp2;
71916   {
71917     try {
71918       result = (arg1)->RemoveChildAt(arg2);
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (...) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71930       };
71931     }
71932   }
71933   jresult = new Dali::Actor((const Dali::Actor &)result);
71934   return jresult;
71935 }
71936
71937
71938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
71939   unsigned int jresult ;
71940   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71941   Dali::Actor arg2 ;
71942   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
71943   Dali::Actor *argp2 ;
71944   bool result;
71945
71946   arg1 = (Dali::Toolkit::TableView *)jarg1;
71947   argp2 = (Dali::Actor *)jarg2;
71948   if (!argp2) {
71949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71950     return 0;
71951   }
71952   arg2 = *argp2;
71953   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
71954   if (!arg3) {
71955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
71956     return 0;
71957   }
71958   {
71959     try {
71960       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
71961     } catch (std::out_of_range& e) {
71962       {
71963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71964       };
71965     } catch (std::exception& e) {
71966       {
71967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71968       };
71969     } catch (...) {
71970       {
71971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71972       };
71973     }
71974   }
71975   jresult = result;
71976   return jresult;
71977 }
71978
71979
71980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
71981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
71982   unsigned int arg2 ;
71983
71984   arg1 = (Dali::Toolkit::TableView *)jarg1;
71985   arg2 = (unsigned int)jarg2;
71986   {
71987     try {
71988       (arg1)->InsertRow(arg2);
71989     } catch (std::out_of_range& e) {
71990       {
71991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71992       };
71993     } catch (std::exception& e) {
71994       {
71995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71996       };
71997     } catch (...) {
71998       {
71999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72000       };
72001     }
72002   }
72003 }
72004
72005
72006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
72007   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72008   unsigned int arg2 ;
72009
72010   arg1 = (Dali::Toolkit::TableView *)jarg1;
72011   arg2 = (unsigned int)jarg2;
72012   {
72013     try {
72014       (arg1)->DeleteRow(arg2);
72015     } catch (std::out_of_range& e) {
72016       {
72017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72018       };
72019     } catch (std::exception& e) {
72020       {
72021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72022       };
72023     } catch (...) {
72024       {
72025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72026       };
72027     }
72028   }
72029 }
72030
72031
72032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
72033   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72034   unsigned int arg2 ;
72035   std::vector< Dali::Actor > *arg3 = 0 ;
72036
72037   arg1 = (Dali::Toolkit::TableView *)jarg1;
72038   arg2 = (unsigned int)jarg2;
72039   arg3 = (std::vector< Dali::Actor > *)jarg3;
72040   if (!arg3) {
72041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72042     return ;
72043   }
72044   {
72045     try {
72046       (arg1)->DeleteRow(arg2,*arg3);
72047     } catch (std::out_of_range& e) {
72048       {
72049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72050       };
72051     } catch (std::exception& e) {
72052       {
72053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72054       };
72055     } catch (...) {
72056       {
72057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72058       };
72059     }
72060   }
72061 }
72062
72063
72064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
72065   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72066   unsigned int arg2 ;
72067
72068   arg1 = (Dali::Toolkit::TableView *)jarg1;
72069   arg2 = (unsigned int)jarg2;
72070   {
72071     try {
72072       (arg1)->InsertColumn(arg2);
72073     } catch (std::out_of_range& e) {
72074       {
72075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (std::exception& e) {
72078       {
72079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72084       };
72085     }
72086   }
72087 }
72088
72089
72090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
72091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72092   unsigned int arg2 ;
72093
72094   arg1 = (Dali::Toolkit::TableView *)jarg1;
72095   arg2 = (unsigned int)jarg2;
72096   {
72097     try {
72098       (arg1)->DeleteColumn(arg2);
72099     } catch (std::out_of_range& e) {
72100       {
72101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72102       };
72103     } catch (std::exception& e) {
72104       {
72105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72106       };
72107     } catch (...) {
72108       {
72109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72110       };
72111     }
72112   }
72113 }
72114
72115
72116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
72117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72118   unsigned int arg2 ;
72119   std::vector< Dali::Actor > *arg3 = 0 ;
72120
72121   arg1 = (Dali::Toolkit::TableView *)jarg1;
72122   arg2 = (unsigned int)jarg2;
72123   arg3 = (std::vector< Dali::Actor > *)jarg3;
72124   if (!arg3) {
72125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72126     return ;
72127   }
72128   {
72129     try {
72130       (arg1)->DeleteColumn(arg2,*arg3);
72131     } catch (std::out_of_range& e) {
72132       {
72133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72134       };
72135     } catch (std::exception& e) {
72136       {
72137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72138       };
72139     } catch (...) {
72140       {
72141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72142       };
72143     }
72144   }
72145 }
72146
72147
72148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
72149   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72150   unsigned int arg2 ;
72151   unsigned int arg3 ;
72152
72153   arg1 = (Dali::Toolkit::TableView *)jarg1;
72154   arg2 = (unsigned int)jarg2;
72155   arg3 = (unsigned int)jarg3;
72156   {
72157     try {
72158       (arg1)->Resize(arg2,arg3);
72159     } catch (std::out_of_range& e) {
72160       {
72161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72162       };
72163     } catch (std::exception& e) {
72164       {
72165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72166       };
72167     } catch (...) {
72168       {
72169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72170       };
72171     }
72172   }
72173 }
72174
72175
72176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
72177   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72178   unsigned int arg2 ;
72179   unsigned int arg3 ;
72180   std::vector< Dali::Actor > *arg4 = 0 ;
72181
72182   arg1 = (Dali::Toolkit::TableView *)jarg1;
72183   arg2 = (unsigned int)jarg2;
72184   arg3 = (unsigned int)jarg3;
72185   arg4 = (std::vector< Dali::Actor > *)jarg4;
72186   if (!arg4) {
72187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
72188     return ;
72189   }
72190   {
72191     try {
72192       (arg1)->Resize(arg2,arg3,*arg4);
72193     } catch (std::out_of_range& e) {
72194       {
72195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72196       };
72197     } catch (std::exception& e) {
72198       {
72199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72200       };
72201     } catch (...) {
72202       {
72203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72204       };
72205     }
72206   }
72207 }
72208
72209
72210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
72211   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72212   Dali::Size arg2 ;
72213   Dali::Size *argp2 ;
72214
72215   arg1 = (Dali::Toolkit::TableView *)jarg1;
72216   argp2 = (Dali::Size *)jarg2;
72217   if (!argp2) {
72218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
72219     return ;
72220   }
72221   arg2 = *argp2;
72222   {
72223     try {
72224       (arg1)->SetCellPadding(arg2);
72225     } catch (std::out_of_range& e) {
72226       {
72227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72228       };
72229     } catch (std::exception& e) {
72230       {
72231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (...) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72236       };
72237     }
72238   }
72239 }
72240
72241
72242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
72243   void * jresult ;
72244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72245   Dali::Size result;
72246
72247   arg1 = (Dali::Toolkit::TableView *)jarg1;
72248   {
72249     try {
72250       result = (arg1)->GetCellPadding();
72251     } catch (std::out_of_range& e) {
72252       {
72253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72254       };
72255     } catch (std::exception& e) {
72256       {
72257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72258       };
72259     } catch (...) {
72260       {
72261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72262       };
72263     }
72264   }
72265   jresult = new Dali::Size((const Dali::Size &)result);
72266   return jresult;
72267 }
72268
72269
72270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
72271   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72272   unsigned int arg2 ;
72273
72274   arg1 = (Dali::Toolkit::TableView *)jarg1;
72275   arg2 = (unsigned int)jarg2;
72276   {
72277     try {
72278       (arg1)->SetFitHeight(arg2);
72279     } catch (std::out_of_range& e) {
72280       {
72281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72282       };
72283     } catch (std::exception& e) {
72284       {
72285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72286       };
72287     } catch (...) {
72288       {
72289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72290       };
72291     }
72292   }
72293 }
72294
72295
72296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
72297   unsigned int jresult ;
72298   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72299   unsigned int arg2 ;
72300   bool result;
72301
72302   arg1 = (Dali::Toolkit::TableView *)jarg1;
72303   arg2 = (unsigned int)jarg2;
72304   {
72305     try {
72306       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
72307     } catch (std::out_of_range& e) {
72308       {
72309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72310       };
72311     } catch (std::exception& e) {
72312       {
72313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72314       };
72315     } catch (...) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72318       };
72319     }
72320   }
72321   jresult = result;
72322   return jresult;
72323 }
72324
72325
72326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
72327   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72328   unsigned int arg2 ;
72329
72330   arg1 = (Dali::Toolkit::TableView *)jarg1;
72331   arg2 = (unsigned int)jarg2;
72332   {
72333     try {
72334       (arg1)->SetFitWidth(arg2);
72335     } catch (std::out_of_range& e) {
72336       {
72337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72338       };
72339     } catch (std::exception& e) {
72340       {
72341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72342       };
72343     } catch (...) {
72344       {
72345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72346       };
72347     }
72348   }
72349 }
72350
72351
72352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
72353   unsigned int jresult ;
72354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72355   unsigned int arg2 ;
72356   bool result;
72357
72358   arg1 = (Dali::Toolkit::TableView *)jarg1;
72359   arg2 = (unsigned int)jarg2;
72360   {
72361     try {
72362       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
72363     } catch (std::out_of_range& e) {
72364       {
72365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72366       };
72367     } catch (std::exception& e) {
72368       {
72369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72374       };
72375     }
72376   }
72377   jresult = result;
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72384   unsigned int arg2 ;
72385   float arg3 ;
72386
72387   arg1 = (Dali::Toolkit::TableView *)jarg1;
72388   arg2 = (unsigned int)jarg2;
72389   arg3 = (float)jarg3;
72390   {
72391     try {
72392       (arg1)->SetFixedHeight(arg2,arg3);
72393     } catch (std::out_of_range& e) {
72394       {
72395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72396       };
72397     } catch (std::exception& e) {
72398       {
72399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72404       };
72405     }
72406   }
72407 }
72408
72409
72410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
72411   float jresult ;
72412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72413   unsigned int arg2 ;
72414   float result;
72415
72416   arg1 = (Dali::Toolkit::TableView *)jarg1;
72417   arg2 = (unsigned int)jarg2;
72418   {
72419     try {
72420       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
72421     } catch (std::out_of_range& e) {
72422       {
72423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (std::exception& e) {
72426       {
72427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72428       };
72429     } catch (...) {
72430       {
72431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72432       };
72433     }
72434   }
72435   jresult = result;
72436   return jresult;
72437 }
72438
72439
72440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
72441   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72442   unsigned int arg2 ;
72443   float arg3 ;
72444
72445   arg1 = (Dali::Toolkit::TableView *)jarg1;
72446   arg2 = (unsigned int)jarg2;
72447   arg3 = (float)jarg3;
72448   {
72449     try {
72450       (arg1)->SetRelativeHeight(arg2,arg3);
72451     } catch (std::out_of_range& e) {
72452       {
72453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72454       };
72455     } catch (std::exception& e) {
72456       {
72457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72458       };
72459     } catch (...) {
72460       {
72461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72462       };
72463     }
72464   }
72465 }
72466
72467
72468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
72469   float jresult ;
72470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72471   unsigned int arg2 ;
72472   float result;
72473
72474   arg1 = (Dali::Toolkit::TableView *)jarg1;
72475   arg2 = (unsigned int)jarg2;
72476   {
72477     try {
72478       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
72479     } catch (std::out_of_range& e) {
72480       {
72481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72482       };
72483     } catch (std::exception& e) {
72484       {
72485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72486       };
72487     } catch (...) {
72488       {
72489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72490       };
72491     }
72492   }
72493   jresult = result;
72494   return jresult;
72495 }
72496
72497
72498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72499   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72500   unsigned int arg2 ;
72501   float arg3 ;
72502
72503   arg1 = (Dali::Toolkit::TableView *)jarg1;
72504   arg2 = (unsigned int)jarg2;
72505   arg3 = (float)jarg3;
72506   {
72507     try {
72508       (arg1)->SetFixedWidth(arg2,arg3);
72509     } catch (std::out_of_range& e) {
72510       {
72511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72512       };
72513     } catch (std::exception& e) {
72514       {
72515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72516       };
72517     } catch (...) {
72518       {
72519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72520       };
72521     }
72522   }
72523 }
72524
72525
72526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
72527   float jresult ;
72528   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72529   unsigned int arg2 ;
72530   float result;
72531
72532   arg1 = (Dali::Toolkit::TableView *)jarg1;
72533   arg2 = (unsigned int)jarg2;
72534   {
72535     try {
72536       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
72537     } catch (std::out_of_range& e) {
72538       {
72539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72540       };
72541     } catch (std::exception& e) {
72542       {
72543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (...) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72548       };
72549     }
72550   }
72551   jresult = result;
72552   return jresult;
72553 }
72554
72555
72556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
72557   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72558   unsigned int arg2 ;
72559   float arg3 ;
72560
72561   arg1 = (Dali::Toolkit::TableView *)jarg1;
72562   arg2 = (unsigned int)jarg2;
72563   arg3 = (float)jarg3;
72564   {
72565     try {
72566       (arg1)->SetRelativeWidth(arg2,arg3);
72567     } catch (std::out_of_range& e) {
72568       {
72569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72570       };
72571     } catch (std::exception& e) {
72572       {
72573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72574       };
72575     } catch (...) {
72576       {
72577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72578       };
72579     }
72580   }
72581 }
72582
72583
72584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
72585   float jresult ;
72586   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72587   unsigned int arg2 ;
72588   float result;
72589
72590   arg1 = (Dali::Toolkit::TableView *)jarg1;
72591   arg2 = (unsigned int)jarg2;
72592   {
72593     try {
72594       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
72595     } catch (std::out_of_range& e) {
72596       {
72597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (std::exception& e) {
72600       {
72601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72602       };
72603     } catch (...) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72606       };
72607     }
72608   }
72609   jresult = result;
72610   return jresult;
72611 }
72612
72613
72614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
72615   unsigned int jresult ;
72616   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72617   unsigned int result;
72618
72619   arg1 = (Dali::Toolkit::TableView *)jarg1;
72620   {
72621     try {
72622       result = (unsigned int)(arg1)->GetRows();
72623     } catch (std::out_of_range& e) {
72624       {
72625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72626       };
72627     } catch (std::exception& e) {
72628       {
72629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72630       };
72631     } catch (...) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72634       };
72635     }
72636   }
72637   jresult = result;
72638   return jresult;
72639 }
72640
72641
72642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
72643   unsigned int jresult ;
72644   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72645   unsigned int result;
72646
72647   arg1 = (Dali::Toolkit::TableView *)jarg1;
72648   {
72649     try {
72650       result = (unsigned int)(arg1)->GetColumns();
72651     } catch (std::out_of_range& e) {
72652       {
72653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72654       };
72655     } catch (std::exception& e) {
72656       {
72657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72658       };
72659     } catch (...) {
72660       {
72661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72662       };
72663     }
72664   }
72665   jresult = result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
72671   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
72672   Dali::Toolkit::TableView::CellPosition arg2 ;
72673   Dali::HorizontalAlignment::Type arg3 ;
72674   Dali::VerticalAlignment::Type arg4 ;
72675   Dali::Toolkit::TableView::CellPosition *argp2 ;
72676
72677   arg1 = (Dali::Toolkit::TableView *)jarg1;
72678   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
72679   if (!argp2) {
72680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
72681     return ;
72682   }
72683   arg2 = *argp2;
72684   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
72685   arg4 = (Dali::VerticalAlignment::Type)jarg4;
72686   {
72687     try {
72688       (arg1)->SetCellAlignment(arg2,arg3,arg4);
72689     } catch (std::out_of_range& e) {
72690       {
72691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72692       };
72693     } catch (std::exception& e) {
72694       {
72695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72696       };
72697     } catch (...) {
72698       {
72699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72700       };
72701     }
72702   }
72703 }
72704
72705
72706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
72707   unsigned int jresult ;
72708   unsigned int result;
72709
72710   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
72711   jresult = result;
72712   return jresult;
72713 }
72714
72715
72716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
72717   int jresult ;
72718   int result;
72719
72720   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
72721   jresult = (int)result;
72722   return jresult;
72723 }
72724
72725
72726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
72727   int jresult ;
72728   int result;
72729
72730   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
72731   jresult = (int)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
72737   int jresult ;
72738   int result;
72739
72740   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
72741   jresult = (int)result;
72742   return jresult;
72743 }
72744
72745
72746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
72747   int jresult ;
72748   int result;
72749
72750   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
72751   jresult = (int)result;
72752   return jresult;
72753 }
72754
72755
72756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
72757   int jresult ;
72758   int result;
72759
72760   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
72761   jresult = (int)result;
72762   return jresult;
72763 }
72764
72765
72766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
72767   int jresult ;
72768   int result;
72769
72770   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
72771   jresult = (int)result;
72772   return jresult;
72773 }
72774
72775
72776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
72777   int jresult ;
72778   int result;
72779
72780   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
72781   jresult = (int)result;
72782   return jresult;
72783 }
72784
72785
72786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
72787   int jresult ;
72788   int result;
72789
72790   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
72791   jresult = (int)result;
72792   return jresult;
72793 }
72794
72795
72796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
72797   int jresult ;
72798   int result;
72799
72800   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
72801   jresult = (int)result;
72802   return jresult;
72803 }
72804
72805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
72806   int jresult ;
72807   int result;
72808
72809   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
72810   jresult = (int)result;
72811   return jresult;
72812 }
72813
72814
72815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
72816   int jresult ;
72817   int result;
72818
72819   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
72820   jresult = (int)result;
72821   return jresult;
72822 }
72823
72824
72825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
72826   int jresult ;
72827   int result;
72828
72829   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
72830   jresult = (int)result;
72831   return jresult;
72832 }
72833
72834
72835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
72836   int jresult ;
72837   int result;
72838
72839   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
72840   jresult = (int)result;
72841   return jresult;
72842 }
72843
72844
72845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
72846   int jresult ;
72847   int result;
72848
72849   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
72850   jresult = (int)result;
72851   return jresult;
72852 }
72853
72854
72855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
72856   int jresult ;
72857   int result;
72858
72859   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
72860   jresult = (int)result;
72861   return jresult;
72862 }
72863
72864
72865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
72866   int jresult ;
72867   int result;
72868
72869   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
72870   jresult = (int)result;
72871   return jresult;
72872 }
72873
72874
72875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
72876   int jresult ;
72877   int result;
72878
72879   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
72880   jresult = (int)result;
72881   return jresult;
72882 }
72883
72884
72885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
72886   int jresult ;
72887   int result;
72888
72889   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
72890   jresult = (int)result;
72891   return jresult;
72892 }
72893
72894
72895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
72896   int jresult ;
72897   int result;
72898
72899   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
72900   jresult = (int)result;
72901   return jresult;
72902 }
72903
72904
72905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
72906   int jresult ;
72907   int result;
72908
72909   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
72910   jresult = (int)result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
72916   int jresult ;
72917   int result;
72918
72919   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
72920   jresult = (int)result;
72921   return jresult;
72922 }
72923
72924
72925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
72926   int jresult ;
72927   int result;
72928
72929   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
72930   jresult = (int)result;
72931   return jresult;
72932 }
72933
72934
72935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
72936   int jresult ;
72937   int result;
72938
72939   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
72940   jresult = (int)result;
72941   return jresult;
72942 }
72943
72944
72945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
72946   int jresult ;
72947   int result;
72948
72949   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
72950   jresult = (int)result;
72951   return jresult;
72952 }
72953
72954
72955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
72956   void * jresult ;
72957   Dali::Toolkit::TextLabel::Property *result = 0 ;
72958
72959   {
72960     try {
72961       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
72962     } catch (std::out_of_range& e) {
72963       {
72964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (std::exception& e) {
72967       {
72968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72969       };
72970     } catch (...) {
72971       {
72972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72973       };
72974     }
72975   }
72976   jresult = (void *)result;
72977   return jresult;
72978 }
72979
72980
72981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
72982   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
72983
72984   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
72985   {
72986     try {
72987       delete arg1;
72988     } catch (std::out_of_range& e) {
72989       {
72990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72991       };
72992     } catch (std::exception& e) {
72993       {
72994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (...) {
72997       {
72998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72999       };
73000     }
73001   }
73002 }
73003
73004
73005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
73006   void * jresult ;
73007   Dali::Toolkit::TextLabel result;
73008
73009   {
73010     try {
73011       result = Dali::Toolkit::TextLabel::New();
73012     } catch (std::out_of_range& e) {
73013       {
73014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73015       };
73016     } catch (std::exception& e) {
73017       {
73018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73019       };
73020     } catch (...) {
73021       {
73022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73023       };
73024     }
73025   }
73026   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73027   return jresult;
73028 }
73029
73030
73031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
73032   void * jresult ;
73033   std::string *arg1 = 0 ;
73034   Dali::Toolkit::TextLabel result;
73035
73036   if (!jarg1) {
73037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73038     return 0;
73039   }
73040   std::string arg1_str(jarg1);
73041   arg1 = &arg1_str;
73042   {
73043     try {
73044       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
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 = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73060
73061   //argout typemap for const std::string&
73062
73063   return jresult;
73064 }
73065
73066
73067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
73068   void * jresult ;
73069   Dali::Toolkit::TextLabel *result = 0 ;
73070
73071   {
73072     try {
73073       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
73074     } catch (std::out_of_range& e) {
73075       {
73076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73077       };
73078     } catch (std::exception& e) {
73079       {
73080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73081       };
73082     } catch (...) {
73083       {
73084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73085       };
73086     }
73087   }
73088   jresult = (void *)result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
73094   void * jresult ;
73095   Dali::Toolkit::TextLabel *arg1 = 0 ;
73096   Dali::Toolkit::TextLabel *result = 0 ;
73097
73098   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73099   if (!arg1) {
73100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
73101     return 0;
73102   }
73103   {
73104     try {
73105       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
73106     } catch (std::out_of_range& e) {
73107       {
73108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73109       };
73110     } catch (std::exception& e) {
73111       {
73112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73113       };
73114     } catch (...) {
73115       {
73116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73117       };
73118     }
73119   }
73120   jresult = (void *)result;
73121   return jresult;
73122 }
73123
73124
73125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
73126   void * jresult ;
73127   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
73128   Dali::Toolkit::TextLabel *arg2 = 0 ;
73129   Dali::Toolkit::TextLabel *result = 0 ;
73130
73131   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73132   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
73133   if (!arg2) {
73134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
73135     return 0;
73136   }
73137   {
73138     try {
73139       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
73140     } catch (std::out_of_range& e) {
73141       {
73142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73143       };
73144     } catch (std::exception& e) {
73145       {
73146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73147       };
73148     } catch (...) {
73149       {
73150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73151       };
73152     }
73153   }
73154   jresult = (void *)result;
73155   return jresult;
73156 }
73157
73158
73159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
73160   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
73161
73162   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
73163   {
73164     try {
73165       delete arg1;
73166     } catch (std::out_of_range& e) {
73167       {
73168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73169       };
73170     } catch (std::exception& e) {
73171       {
73172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73173       };
73174     } catch (...) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73177       };
73178     }
73179   }
73180 }
73181
73182
73183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
73184   void * jresult ;
73185   Dali::BaseHandle arg1 ;
73186   Dali::BaseHandle *argp1 ;
73187   Dali::Toolkit::TextLabel result;
73188
73189   argp1 = (Dali::BaseHandle *)jarg1;
73190   if (!argp1) {
73191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73192     return 0;
73193   }
73194   arg1 = *argp1;
73195   {
73196     try {
73197       result = Dali::Toolkit::TextLabel::DownCast(arg1);
73198     } catch (std::out_of_range& e) {
73199       {
73200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (std::exception& e) {
73203       {
73204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73205       };
73206     } catch (...) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73209       };
73210     }
73211   }
73212   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
73213   return jresult;
73214 }
73215
73216
73217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
73218   void * jresult ;
73219   Dali::Toolkit::AccessibilityManager *result = 0 ;
73220
73221   {
73222     try {
73223       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (...) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73235       };
73236     }
73237   }
73238   jresult = (void *)result;
73239   return jresult;
73240 }
73241
73242
73243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
73244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73245
73246   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73247   {
73248     try {
73249       delete arg1;
73250     } catch (std::out_of_range& e) {
73251       {
73252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73253       };
73254     } catch (std::exception& e) {
73255       {
73256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73257       };
73258     } catch (...) {
73259       {
73260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73261       };
73262     }
73263   }
73264 }
73265
73266
73267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
73268   void * jresult ;
73269   Dali::Toolkit::AccessibilityManager result;
73270
73271   {
73272     try {
73273       result = Dali::Toolkit::AccessibilityManager::Get();
73274     } catch (std::out_of_range& e) {
73275       {
73276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73277       };
73278     } catch (std::exception& e) {
73279       {
73280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73281       };
73282     } catch (...) {
73283       {
73284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73285       };
73286     }
73287   }
73288   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
73289   return jresult;
73290 }
73291
73292
73293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
73294   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73295   Dali::Actor arg2 ;
73296   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73297   std::string *arg4 = 0 ;
73298   Dali::Actor *argp2 ;
73299
73300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73301   argp2 = (Dali::Actor *)jarg2;
73302   if (!argp2) {
73303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73304     return ;
73305   }
73306   arg2 = *argp2;
73307   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73308   if (!jarg4) {
73309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
73310     return ;
73311   }
73312   std::string arg4_str(jarg4);
73313   arg4 = &arg4_str;
73314   {
73315     try {
73316       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
73317     } catch (std::out_of_range& e) {
73318       {
73319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73320       };
73321     } catch (std::exception& e) {
73322       {
73323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73324       };
73325     } catch (...) {
73326       {
73327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73328       };
73329     }
73330   }
73331
73332   //argout typemap for const std::string&
73333
73334 }
73335
73336
73337 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
73338   char * jresult ;
73339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73340   Dali::Actor arg2 ;
73341   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
73342   Dali::Actor *argp2 ;
73343   std::string result;
73344
73345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73346   argp2 = (Dali::Actor *)jarg2;
73347   if (!argp2) {
73348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73349     return 0;
73350   }
73351   arg2 = *argp2;
73352   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
73353   {
73354     try {
73355       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73367       };
73368     }
73369   }
73370   jresult = SWIG_csharp_string_callback((&result)->c_str());
73371   return jresult;
73372 }
73373
73374
73375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
73376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73377   Dali::Actor arg2 ;
73378   unsigned int arg3 ;
73379   Dali::Actor *argp2 ;
73380
73381   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73382   argp2 = (Dali::Actor *)jarg2;
73383   if (!argp2) {
73384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73385     return ;
73386   }
73387   arg2 = *argp2;
73388   arg3 = (unsigned int)jarg3;
73389   {
73390     try {
73391       (arg1)->SetFocusOrder(arg2,arg3);
73392     } catch (std::out_of_range& e) {
73393       {
73394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73395       };
73396     } catch (std::exception& e) {
73397       {
73398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73399       };
73400     } catch (...) {
73401       {
73402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73403       };
73404     }
73405   }
73406 }
73407
73408
73409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
73410   unsigned int jresult ;
73411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73412   Dali::Actor arg2 ;
73413   Dali::Actor *argp2 ;
73414   unsigned int result;
73415
73416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73417   argp2 = (Dali::Actor *)jarg2;
73418   if (!argp2) {
73419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73420     return 0;
73421   }
73422   arg2 = *argp2;
73423   {
73424     try {
73425       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
73426     } catch (std::out_of_range& e) {
73427       {
73428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (std::exception& e) {
73431       {
73432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440   jresult = result;
73441   return jresult;
73442 }
73443
73444
73445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
73446   unsigned int jresult ;
73447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73448   unsigned int result;
73449
73450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73451   {
73452     try {
73453       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
73454     } catch (std::out_of_range& e) {
73455       {
73456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73457       };
73458     } catch (std::exception& e) {
73459       {
73460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73461       };
73462     } catch (...) {
73463       {
73464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73465       };
73466     }
73467   }
73468   jresult = result;
73469   return jresult;
73470 }
73471
73472
73473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
73474   void * jresult ;
73475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73476   unsigned int arg2 ;
73477   Dali::Actor result;
73478
73479   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73480   arg2 = (unsigned int)jarg2;
73481   {
73482     try {
73483       result = (arg1)->GetActorByFocusOrder(arg2);
73484     } catch (std::out_of_range& e) {
73485       {
73486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73487       };
73488     } catch (std::exception& e) {
73489       {
73490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73491       };
73492     } catch (...) {
73493       {
73494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73495       };
73496     }
73497   }
73498   jresult = new Dali::Actor((const Dali::Actor &)result);
73499   return jresult;
73500 }
73501
73502
73503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
73504   unsigned int jresult ;
73505   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73506   Dali::Actor arg2 ;
73507   Dali::Actor *argp2 ;
73508   bool result;
73509
73510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73511   argp2 = (Dali::Actor *)jarg2;
73512   if (!argp2) {
73513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73514     return 0;
73515   }
73516   arg2 = *argp2;
73517   {
73518     try {
73519       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
73520     } catch (std::out_of_range& e) {
73521       {
73522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73523       };
73524     } catch (std::exception& e) {
73525       {
73526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (...) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73531       };
73532     }
73533   }
73534   jresult = result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
73540   void * jresult ;
73541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73542   Dali::Actor result;
73543
73544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73545   {
73546     try {
73547       result = (arg1)->GetCurrentFocusActor();
73548     } catch (std::out_of_range& e) {
73549       {
73550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73551       };
73552     } catch (std::exception& e) {
73553       {
73554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73555       };
73556     } catch (...) {
73557       {
73558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73559       };
73560     }
73561   }
73562   jresult = new Dali::Actor((const Dali::Actor &)result);
73563   return jresult;
73564 }
73565
73566
73567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
73568   void * jresult ;
73569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73570   Dali::Actor result;
73571
73572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73573   {
73574     try {
73575       result = (arg1)->GetCurrentFocusGroup();
73576     } catch (std::out_of_range& e) {
73577       {
73578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73579       };
73580     } catch (std::exception& e) {
73581       {
73582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73583       };
73584     } catch (...) {
73585       {
73586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73587       };
73588     }
73589   }
73590   jresult = new Dali::Actor((const Dali::Actor &)result);
73591   return jresult;
73592 }
73593
73594
73595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
73596   unsigned int jresult ;
73597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73598   unsigned int result;
73599
73600   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73601   {
73602     try {
73603       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
73604     } catch (std::out_of_range& e) {
73605       {
73606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (std::exception& e) {
73609       {
73610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73615       };
73616     }
73617   }
73618   jresult = result;
73619   return jresult;
73620 }
73621
73622
73623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
73624   unsigned int jresult ;
73625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73626   bool result;
73627
73628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73629   {
73630     try {
73631       result = (bool)(arg1)->MoveFocusForward();
73632     } catch (std::out_of_range& e) {
73633       {
73634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (std::exception& e) {
73637       {
73638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73643       };
73644     }
73645   }
73646   jresult = result;
73647   return jresult;
73648 }
73649
73650
73651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
73652   unsigned int jresult ;
73653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73654   bool result;
73655
73656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73657   {
73658     try {
73659       result = (bool)(arg1)->MoveFocusBackward();
73660     } catch (std::out_of_range& e) {
73661       {
73662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73663       };
73664     } catch (std::exception& e) {
73665       {
73666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73667       };
73668     } catch (...) {
73669       {
73670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73671       };
73672     }
73673   }
73674   jresult = result;
73675   return jresult;
73676 }
73677
73678
73679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
73680   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73681
73682   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73683   {
73684     try {
73685       (arg1)->ClearFocus();
73686     } catch (std::out_of_range& e) {
73687       {
73688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73689       };
73690     } catch (std::exception& e) {
73691       {
73692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73693       };
73694     } catch (...) {
73695       {
73696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73697       };
73698     }
73699   }
73700 }
73701
73702
73703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
73704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73705
73706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73707   {
73708     try {
73709       (arg1)->Reset();
73710     } catch (std::out_of_range& e) {
73711       {
73712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73713       };
73714     } catch (std::exception& e) {
73715       {
73716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73717       };
73718     } catch (...) {
73719       {
73720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73721       };
73722     }
73723   }
73724 }
73725
73726
73727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
73728   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73729   Dali::Actor arg2 ;
73730   bool arg3 ;
73731   Dali::Actor *argp2 ;
73732
73733   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73734   argp2 = (Dali::Actor *)jarg2;
73735   if (!argp2) {
73736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73737     return ;
73738   }
73739   arg2 = *argp2;
73740   arg3 = jarg3 ? true : false;
73741   {
73742     try {
73743       (arg1)->SetFocusGroup(arg2,arg3);
73744     } catch (std::out_of_range& e) {
73745       {
73746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73747       };
73748     } catch (std::exception& e) {
73749       {
73750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73751       };
73752     } catch (...) {
73753       {
73754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73755       };
73756     }
73757   }
73758 }
73759
73760
73761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
73762   unsigned int jresult ;
73763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73764   Dali::Actor arg2 ;
73765   Dali::Actor *argp2 ;
73766   bool result;
73767
73768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73769   argp2 = (Dali::Actor *)jarg2;
73770   if (!argp2) {
73771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73772     return 0;
73773   }
73774   arg2 = *argp2;
73775   {
73776     try {
73777       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
73778     } catch (std::out_of_range& e) {
73779       {
73780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73781       };
73782     } catch (std::exception& e) {
73783       {
73784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73785       };
73786     } catch (...) {
73787       {
73788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73789       };
73790     }
73791   }
73792   jresult = result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
73798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73799   bool arg2 ;
73800
73801   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73802   arg2 = jarg2 ? true : false;
73803   {
73804     try {
73805       (arg1)->SetGroupMode(arg2);
73806     } catch (std::out_of_range& e) {
73807       {
73808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73809       };
73810     } catch (std::exception& e) {
73811       {
73812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73813       };
73814     } catch (...) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73817       };
73818     }
73819   }
73820 }
73821
73822
73823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
73824   unsigned int jresult ;
73825   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73826   bool result;
73827
73828   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73829   {
73830     try {
73831       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
73832     } catch (std::out_of_range& e) {
73833       {
73834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73835       };
73836     } catch (std::exception& e) {
73837       {
73838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73839       };
73840     } catch (...) {
73841       {
73842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73843       };
73844     }
73845   }
73846   jresult = result;
73847   return jresult;
73848 }
73849
73850
73851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
73852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73853   bool arg2 ;
73854
73855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73856   arg2 = jarg2 ? true : false;
73857   {
73858     try {
73859       (arg1)->SetWrapMode(arg2);
73860     } catch (std::out_of_range& e) {
73861       {
73862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73863       };
73864     } catch (std::exception& e) {
73865       {
73866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73867       };
73868     } catch (...) {
73869       {
73870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73871       };
73872     }
73873   }
73874 }
73875
73876
73877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
73878   unsigned int jresult ;
73879   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73880   bool result;
73881
73882   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73883   {
73884     try {
73885       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
73886     } catch (std::out_of_range& e) {
73887       {
73888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73889       };
73890     } catch (std::exception& e) {
73891       {
73892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73893       };
73894     } catch (...) {
73895       {
73896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73897       };
73898     }
73899   }
73900   jresult = result;
73901   return jresult;
73902 }
73903
73904
73905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
73906   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73907   Dali::Actor arg2 ;
73908   Dali::Actor *argp2 ;
73909
73910   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73911   argp2 = (Dali::Actor *)jarg2;
73912   if (!argp2) {
73913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73914     return ;
73915   }
73916   arg2 = *argp2;
73917   {
73918     try {
73919       (arg1)->SetFocusIndicatorActor(arg2);
73920     } catch (std::out_of_range& e) {
73921       {
73922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73923       };
73924     } catch (std::exception& e) {
73925       {
73926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73927       };
73928     } catch (...) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73931       };
73932     }
73933   }
73934 }
73935
73936
73937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
73938   void * jresult ;
73939   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73940   Dali::Actor result;
73941
73942   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73943   {
73944     try {
73945       result = (arg1)->GetFocusIndicatorActor();
73946     } catch (std::out_of_range& e) {
73947       {
73948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73949       };
73950     } catch (std::exception& e) {
73951       {
73952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73953       };
73954     } catch (...) {
73955       {
73956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73957       };
73958     }
73959   }
73960   jresult = new Dali::Actor((const Dali::Actor &)result);
73961   return jresult;
73962 }
73963
73964
73965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
73966   void * jresult ;
73967   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
73968   Dali::Actor arg2 ;
73969   Dali::Actor *argp2 ;
73970   Dali::Actor result;
73971
73972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
73973   argp2 = (Dali::Actor *)jarg2;
73974   if (!argp2) {
73975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73976     return 0;
73977   }
73978   arg2 = *argp2;
73979   {
73980     try {
73981       result = (arg1)->GetFocusGroup(arg2);
73982     } catch (std::out_of_range& e) {
73983       {
73984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73985       };
73986     } catch (std::exception& e) {
73987       {
73988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73989       };
73990     } catch (...) {
73991       {
73992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73993       };
73994     }
73995   }
73996   jresult = new Dali::Actor((const Dali::Actor &)result);
73997   return jresult;
73998 }
73999
74000
74001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
74002   void * jresult ;
74003   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74004   Dali::Vector2 result;
74005
74006   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74007   {
74008     try {
74009       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
74010     } catch (std::out_of_range& e) {
74011       {
74012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74013       };
74014     } catch (std::exception& e) {
74015       {
74016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74017       };
74018     } catch (...) {
74019       {
74020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74021       };
74022     }
74023   }
74024   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74025   return jresult;
74026 }
74027
74028
74029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
74030   void * jresult ;
74031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74032   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
74033
74034   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74035   {
74036     try {
74037       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
74038     } catch (std::out_of_range& e) {
74039       {
74040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74041       };
74042     } catch (std::exception& e) {
74043       {
74044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74045       };
74046     } catch (...) {
74047       {
74048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74049       };
74050     }
74051   }
74052   jresult = (void *)result;
74053   return jresult;
74054 }
74055
74056
74057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
74058   void * jresult ;
74059   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74060   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
74061
74062   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74063   {
74064     try {
74065       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
74066     } catch (std::out_of_range& e) {
74067       {
74068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74069       };
74070     } catch (std::exception& e) {
74071       {
74072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74073       };
74074     } catch (...) {
74075       {
74076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74077       };
74078     }
74079   }
74080   jresult = (void *)result;
74081   return jresult;
74082 }
74083
74084
74085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
74086   void * jresult ;
74087   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74088   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
74089
74090   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74091   {
74092     try {
74093       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
74094     } catch (std::out_of_range& e) {
74095       {
74096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74097       };
74098     } catch (std::exception& e) {
74099       {
74100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74101       };
74102     } catch (...) {
74103       {
74104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74105       };
74106     }
74107   }
74108   jresult = (void *)result;
74109   return jresult;
74110 }
74111
74112
74113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
74114   void * jresult ;
74115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74116   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74117
74118   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74119   {
74120     try {
74121       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
74122     } catch (std::out_of_range& e) {
74123       {
74124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74125       };
74126     } catch (std::exception& e) {
74127       {
74128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74129       };
74130     } catch (...) {
74131       {
74132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74133       };
74134     }
74135   }
74136   jresult = (void *)result;
74137   return jresult;
74138 }
74139
74140
74141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
74142   void * jresult ;
74143   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74144   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74145
74146   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74147   {
74148     try {
74149       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
74150     } catch (std::out_of_range& e) {
74151       {
74152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74153       };
74154     } catch (std::exception& e) {
74155       {
74156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74157       };
74158     } catch (...) {
74159       {
74160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74161       };
74162     }
74163   }
74164   jresult = (void *)result;
74165   return jresult;
74166 }
74167
74168
74169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
74170   void * jresult ;
74171   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74172   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74173
74174   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74175   {
74176     try {
74177       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
74178     } catch (std::out_of_range& e) {
74179       {
74180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74181       };
74182     } catch (std::exception& e) {
74183       {
74184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74185       };
74186     } catch (...) {
74187       {
74188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74189       };
74190     }
74191   }
74192   jresult = (void *)result;
74193   return jresult;
74194 }
74195
74196
74197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
74198   void * jresult ;
74199   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74200   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74201
74202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74203   {
74204     try {
74205       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
74206     } catch (std::out_of_range& e) {
74207       {
74208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74209       };
74210     } catch (std::exception& e) {
74211       {
74212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74213       };
74214     } catch (...) {
74215       {
74216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74217       };
74218     }
74219   }
74220   jresult = (void *)result;
74221   return jresult;
74222 }
74223
74224
74225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
74226   void * jresult ;
74227   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74228   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74229
74230   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74231   {
74232     try {
74233       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
74234     } catch (std::out_of_range& e) {
74235       {
74236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74237       };
74238     } catch (std::exception& e) {
74239       {
74240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74241       };
74242     } catch (...) {
74243       {
74244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74245       };
74246     }
74247   }
74248   jresult = (void *)result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
74254   void * jresult ;
74255   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74256   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74257
74258   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74259   {
74260     try {
74261       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
74262     } catch (std::out_of_range& e) {
74263       {
74264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74265       };
74266     } catch (std::exception& e) {
74267       {
74268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74269       };
74270     } catch (...) {
74271       {
74272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74273       };
74274     }
74275   }
74276   jresult = (void *)result;
74277   return jresult;
74278 }
74279
74280
74281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
74282   void * jresult ;
74283   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74284   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74285
74286   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74287   {
74288     try {
74289       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
74290     } catch (std::out_of_range& e) {
74291       {
74292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74293       };
74294     } catch (std::exception& e) {
74295       {
74296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74297       };
74298     } catch (...) {
74299       {
74300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74301       };
74302     }
74303   }
74304   jresult = (void *)result;
74305   return jresult;
74306 }
74307
74308
74309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
74310   void * jresult ;
74311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74312   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74313
74314   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74315   {
74316     try {
74317       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
74318     } catch (std::out_of_range& e) {
74319       {
74320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74321       };
74322     } catch (std::exception& e) {
74323       {
74324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74325       };
74326     } catch (...) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74329       };
74330     }
74331   }
74332   jresult = (void *)result;
74333   return jresult;
74334 }
74335
74336
74337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
74338   void * jresult ;
74339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74340   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74341
74342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74343   {
74344     try {
74345       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
74346     } catch (std::out_of_range& e) {
74347       {
74348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74349       };
74350     } catch (std::exception& e) {
74351       {
74352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74353       };
74354     } catch (...) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74357       };
74358     }
74359   }
74360   jresult = (void *)result;
74361   return jresult;
74362 }
74363
74364
74365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
74366   void * jresult ;
74367   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74368   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74369
74370   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74371   {
74372     try {
74373       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
74374     } catch (std::out_of_range& e) {
74375       {
74376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74377       };
74378     } catch (std::exception& e) {
74379       {
74380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74381       };
74382     } catch (...) {
74383       {
74384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74385       };
74386     }
74387   }
74388   jresult = (void *)result;
74389   return jresult;
74390 }
74391
74392
74393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
74394   void * jresult ;
74395   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74396   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74397
74398   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74399   {
74400     try {
74401       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
74402     } catch (std::out_of_range& e) {
74403       {
74404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74405       };
74406     } catch (std::exception& e) {
74407       {
74408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74409       };
74410     } catch (...) {
74411       {
74412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74413       };
74414     }
74415   }
74416   jresult = (void *)result;
74417   return jresult;
74418 }
74419
74420
74421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
74422   void * jresult ;
74423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74424   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74425
74426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74427   {
74428     try {
74429       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
74430     } catch (std::out_of_range& e) {
74431       {
74432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74433       };
74434     } catch (std::exception& e) {
74435       {
74436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74437       };
74438     } catch (...) {
74439       {
74440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74441       };
74442     }
74443   }
74444   jresult = (void *)result;
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
74450   void * jresult ;
74451   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74452   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74453
74454   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74455   {
74456     try {
74457       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
74458     } catch (std::out_of_range& e) {
74459       {
74460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74461       };
74462     } catch (std::exception& e) {
74463       {
74464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74465       };
74466     } catch (...) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74469       };
74470     }
74471   }
74472   jresult = (void *)result;
74473   return jresult;
74474 }
74475
74476
74477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
74478   void * jresult ;
74479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74480   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74481
74482   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74483   {
74484     try {
74485       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (...) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74497       };
74498     }
74499   }
74500   jresult = (void *)result;
74501   return jresult;
74502 }
74503
74504
74505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
74506   void * jresult ;
74507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74508   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74509
74510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74511   {
74512     try {
74513       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
74514     } catch (std::out_of_range& e) {
74515       {
74516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74517       };
74518     } catch (std::exception& e) {
74519       {
74520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74521       };
74522     } catch (...) {
74523       {
74524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74525       };
74526     }
74527   }
74528   jresult = (void *)result;
74529   return jresult;
74530 }
74531
74532
74533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
74534   void * jresult ;
74535   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74536   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74537
74538   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74539   {
74540     try {
74541       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
74542     } catch (std::out_of_range& e) {
74543       {
74544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74545       };
74546     } catch (std::exception& e) {
74547       {
74548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74549       };
74550     } catch (...) {
74551       {
74552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74553       };
74554     }
74555   }
74556   jresult = (void *)result;
74557   return jresult;
74558 }
74559
74560
74561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
74562   void * jresult ;
74563   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74564   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74565
74566   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74567   {
74568     try {
74569       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
74570     } catch (std::out_of_range& e) {
74571       {
74572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74573       };
74574     } catch (std::exception& e) {
74575       {
74576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74577       };
74578     } catch (...) {
74579       {
74580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74581       };
74582     }
74583   }
74584   jresult = (void *)result;
74585   return jresult;
74586 }
74587
74588
74589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
74590   void * jresult ;
74591   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74592   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74593
74594   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74595   {
74596     try {
74597       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
74598     } catch (std::out_of_range& e) {
74599       {
74600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74601       };
74602     } catch (std::exception& e) {
74603       {
74604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74605       };
74606     } catch (...) {
74607       {
74608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74609       };
74610     }
74611   }
74612   jresult = (void *)result;
74613   return jresult;
74614 }
74615
74616
74617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
74618   void * jresult ;
74619   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74620   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74621
74622   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74623   {
74624     try {
74625       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
74626     } catch (std::out_of_range& e) {
74627       {
74628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74629       };
74630     } catch (std::exception& e) {
74631       {
74632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74633       };
74634     } catch (...) {
74635       {
74636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74637       };
74638     }
74639   }
74640   jresult = (void *)result;
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
74646   void * jresult ;
74647   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74648   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74649
74650   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74651   {
74652     try {
74653       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
74654     } catch (std::out_of_range& e) {
74655       {
74656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74657       };
74658     } catch (std::exception& e) {
74659       {
74660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74661       };
74662     } catch (...) {
74663       {
74664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74665       };
74666     }
74667   }
74668   jresult = (void *)result;
74669   return jresult;
74670 }
74671
74672
74673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
74674   void * jresult ;
74675   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74676   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74677
74678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74679   {
74680     try {
74681       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
74682     } catch (std::out_of_range& e) {
74683       {
74684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74685       };
74686     } catch (std::exception& e) {
74687       {
74688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74689       };
74690     } catch (...) {
74691       {
74692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74693       };
74694     }
74695   }
74696   jresult = (void *)result;
74697   return jresult;
74698 }
74699
74700
74701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
74702   void * jresult ;
74703   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74704   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74705
74706   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74707   {
74708     try {
74709       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
74710     } catch (std::out_of_range& e) {
74711       {
74712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74713       };
74714     } catch (std::exception& e) {
74715       {
74716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74717       };
74718     } catch (...) {
74719       {
74720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74721       };
74722     }
74723   }
74724   jresult = (void *)result;
74725   return jresult;
74726 }
74727
74728
74729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
74730   void * jresult ;
74731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74732   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74733
74734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74735   {
74736     try {
74737       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
74738     } catch (std::out_of_range& e) {
74739       {
74740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74741       };
74742     } catch (std::exception& e) {
74743       {
74744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74745       };
74746     } catch (...) {
74747       {
74748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74749       };
74750     }
74751   }
74752   jresult = (void *)result;
74753   return jresult;
74754 }
74755
74756
74757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
74758   void * jresult ;
74759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74760   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74761
74762   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74763   {
74764     try {
74765       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
74766     } catch (std::out_of_range& e) {
74767       {
74768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74769       };
74770     } catch (std::exception& e) {
74771       {
74772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74773       };
74774     } catch (...) {
74775       {
74776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74777       };
74778     }
74779   }
74780   jresult = (void *)result;
74781   return jresult;
74782 }
74783
74784
74785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
74786   void * jresult ;
74787   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74788   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74789
74790   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74791   {
74792     try {
74793       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
74794     } catch (std::out_of_range& e) {
74795       {
74796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74797       };
74798     } catch (std::exception& e) {
74799       {
74800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74801       };
74802     } catch (...) {
74803       {
74804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74805       };
74806     }
74807   }
74808   jresult = (void *)result;
74809   return jresult;
74810 }
74811
74812
74813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
74814   void * jresult ;
74815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74816   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
74817
74818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74819   {
74820     try {
74821       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
74822     } catch (std::out_of_range& e) {
74823       {
74824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74825       };
74826     } catch (std::exception& e) {
74827       {
74828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74829       };
74830     } catch (...) {
74831       {
74832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74833       };
74834     }
74835   }
74836   jresult = (void *)result;
74837   return jresult;
74838 }
74839
74840
74841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
74842   void * jresult ;
74843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
74844   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
74845
74846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
74847   {
74848     try {
74849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
74850     } catch (std::out_of_range& e) {
74851       {
74852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74853       };
74854     } catch (std::exception& e) {
74855       {
74856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74857       };
74858     } catch (...) {
74859       {
74860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74861       };
74862     }
74863   }
74864   jresult = (void *)result;
74865   return jresult;
74866 }
74867
74868
74869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
74870   void * jresult ;
74871   Dali::Toolkit::StyleManager *result = 0 ;
74872
74873   {
74874     try {
74875       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
74876     } catch (std::out_of_range& e) {
74877       {
74878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74879       };
74880     } catch (std::exception& e) {
74881       {
74882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74883       };
74884     } catch (...) {
74885       {
74886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74887       };
74888     }
74889   }
74890   jresult = (void *)result;
74891   return jresult;
74892 }
74893
74894
74895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
74896   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74897
74898   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74899   {
74900     try {
74901       delete arg1;
74902     } catch (std::out_of_range& e) {
74903       {
74904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74905       };
74906     } catch (std::exception& e) {
74907       {
74908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74909       };
74910     } catch (...) {
74911       {
74912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74913       };
74914     }
74915   }
74916 }
74917
74918
74919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
74920   void * jresult ;
74921   Dali::Toolkit::StyleManager result;
74922
74923   {
74924     try {
74925       result = Dali::Toolkit::StyleManager::Get();
74926     } catch (std::out_of_range& e) {
74927       {
74928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74929       };
74930     } catch (std::exception& e) {
74931       {
74932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74933       };
74934     } catch (...) {
74935       {
74936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74937       };
74938     }
74939   }
74940   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
74941   return jresult;
74942 }
74943
74944
74945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
74946   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74947   std::string *arg2 = 0 ;
74948
74949   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74950   if (!jarg2) {
74951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
74952     return ;
74953   }
74954   std::string arg2_str(jarg2);
74955   arg2 = &arg2_str;
74956   {
74957     try {
74958       (arg1)->ApplyTheme((std::string const &)*arg2);
74959     } catch (std::out_of_range& e) {
74960       {
74961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74962       };
74963     } catch (std::exception& e) {
74964       {
74965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74966       };
74967     } catch (...) {
74968       {
74969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74970       };
74971     }
74972   }
74973
74974   //argout typemap for const std::string&
74975
74976 }
74977
74978
74979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
74980   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
74981
74982   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
74983   {
74984     try {
74985       (arg1)->ApplyDefaultTheme();
74986     } catch (std::out_of_range& e) {
74987       {
74988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74989       };
74990     } catch (std::exception& e) {
74991       {
74992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74993       };
74994     } catch (...) {
74995       {
74996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74997       };
74998     }
74999   }
75000 }
75001
75002
75003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
75004   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
75005   std::string *arg2 = 0 ;
75006   Dali::Property::Value *arg3 = 0 ;
75007
75008   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
75009   if (!jarg2) {
75010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75011     return ;
75012   }
75013   std::string arg2_str(jarg2);
75014   arg2 = &arg2_str;
75015   arg3 = (Dali::Property::Value *)jarg3;
75016   if (!arg3) {
75017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
75018     return ;
75019   }
75020   {
75021     try {
75022       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
75023     } catch (std::out_of_range& e) {
75024       {
75025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75026       };
75027     } catch (std::exception& e) {
75028       {
75029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75030       };
75031     } catch (...) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75034       };
75035     }
75036   }
75037
75038   //argout typemap for const std::string&
75039
75040 }
75041
75042
75043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
75044   unsigned int jresult ;
75045   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
75046   std::string *arg2 = 0 ;
75047   Dali::Property::Value *arg3 = 0 ;
75048   bool result;
75049
75050   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
75051   if (!jarg2) {
75052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75053     return 0;
75054   }
75055   std::string arg2_str(jarg2);
75056   arg2 = &arg2_str;
75057   arg3 = (Dali::Property::Value *)jarg3;
75058   if (!arg3) {
75059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
75060     return 0;
75061   }
75062   {
75063     try {
75064       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
75065     } catch (std::out_of_range& e) {
75066       {
75067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75068       };
75069     } catch (std::exception& e) {
75070       {
75071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75072       };
75073     } catch (...) {
75074       {
75075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75076       };
75077     }
75078   }
75079   jresult = result;
75080
75081   //argout typemap for const std::string&
75082
75083   return jresult;
75084 }
75085
75086
75087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
75088   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
75089   Dali::Toolkit::Control arg2 ;
75090   std::string *arg3 = 0 ;
75091   std::string *arg4 = 0 ;
75092   Dali::Toolkit::Control *argp2 ;
75093
75094   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
75095   argp2 = (Dali::Toolkit::Control *)jarg2;
75096   if (!argp2) {
75097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
75098     return ;
75099   }
75100   arg2 = *argp2;
75101   if (!jarg3) {
75102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75103     return ;
75104   }
75105   std::string arg3_str(jarg3);
75106   arg3 = &arg3_str;
75107   if (!jarg4) {
75108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75109     return ;
75110   }
75111   std::string arg4_str(jarg4);
75112   arg4 = &arg4_str;
75113   {
75114     try {
75115       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
75116     } catch (std::out_of_range& e) {
75117       {
75118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75119       };
75120     } catch (std::exception& e) {
75121       {
75122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75123       };
75124     } catch (...) {
75125       {
75126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75127       };
75128     }
75129   }
75130
75131   //argout typemap for const std::string&
75132
75133
75134   //argout typemap for const std::string&
75135
75136 }
75137
75138
75139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
75140   void * jresult ;
75141   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
75142   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
75143
75144   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
75145   {
75146     try {
75147       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
75148     } catch (std::out_of_range& e) {
75149       {
75150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75151       };
75152     } catch (std::exception& e) {
75153       {
75154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75155       };
75156     } catch (...) {
75157       {
75158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75159       };
75160     }
75161   }
75162   jresult = (void *)result;
75163   return jresult;
75164 }
75165
75166
75167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
75168   int jresult ;
75169   int result;
75170
75171   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
75172   jresult = (int)result;
75173   return jresult;
75174 }
75175
75176
75177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
75178   int jresult ;
75179   int result;
75180
75181   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
75182   jresult = (int)result;
75183   return jresult;
75184 }
75185
75186
75187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
75188   int jresult ;
75189   int result;
75190
75191   result = (int)Dali::Toolkit::Slider::Property::VALUE;
75192   jresult = (int)result;
75193   return jresult;
75194 }
75195
75196
75197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
75198   int jresult ;
75199   int result;
75200
75201   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
75202   jresult = (int)result;
75203   return jresult;
75204 }
75205
75206
75207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
75208   int jresult ;
75209   int result;
75210
75211   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
75212   jresult = (int)result;
75213   return jresult;
75214 }
75215
75216
75217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
75218   int jresult ;
75219   int result;
75220
75221   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
75222   jresult = (int)result;
75223   return jresult;
75224 }
75225
75226
75227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
75228   int jresult ;
75229   int result;
75230
75231   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
75232   jresult = (int)result;
75233   return jresult;
75234 }
75235
75236
75237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
75238   int jresult ;
75239   int result;
75240
75241   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
75242   jresult = (int)result;
75243   return jresult;
75244 }
75245
75246
75247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
75248   int jresult ;
75249   int result;
75250
75251   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
75252   jresult = (int)result;
75253   return jresult;
75254 }
75255
75256
75257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
75258   int jresult ;
75259   int result;
75260
75261   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
75262   jresult = (int)result;
75263   return jresult;
75264 }
75265
75266
75267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
75268   int jresult ;
75269   int result;
75270
75271   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
75272   jresult = (int)result;
75273   return jresult;
75274 }
75275
75276
75277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
75278   int jresult ;
75279   int result;
75280
75281   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
75282   jresult = (int)result;
75283   return jresult;
75284 }
75285
75286
75287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
75288   int jresult ;
75289   int result;
75290
75291   result = (int)Dali::Toolkit::Slider::Property::MARKS;
75292   jresult = (int)result;
75293   return jresult;
75294 }
75295
75296
75297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
75298   int jresult ;
75299   int result;
75300
75301   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
75302   jresult = (int)result;
75303   return jresult;
75304 }
75305
75306
75307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
75308   int jresult ;
75309   int result;
75310
75311   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
75312   jresult = (int)result;
75313   return jresult;
75314 }
75315
75316
75317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
75318   void * jresult ;
75319   Dali::Toolkit::Slider::Property *result = 0 ;
75320
75321   {
75322     try {
75323       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
75324     } catch (std::out_of_range& e) {
75325       {
75326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75327       };
75328     } catch (std::exception& e) {
75329       {
75330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (...) {
75333       {
75334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75335       };
75336     }
75337   }
75338   jresult = (void *)result;
75339   return jresult;
75340 }
75341
75342
75343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
75344   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
75345
75346   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
75347   {
75348     try {
75349       delete arg1;
75350     } catch (std::out_of_range& e) {
75351       {
75352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75353       };
75354     } catch (std::exception& e) {
75355       {
75356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75357       };
75358     } catch (...) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75361       };
75362     }
75363   }
75364 }
75365
75366
75367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
75368   void * jresult ;
75369   Dali::Toolkit::Slider result;
75370
75371   {
75372     try {
75373       result = Dali::Toolkit::Slider::New();
75374     } catch (std::out_of_range& e) {
75375       {
75376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75377       };
75378     } catch (std::exception& e) {
75379       {
75380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75385       };
75386     }
75387   }
75388   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75389   return jresult;
75390 }
75391
75392
75393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
75394   void * jresult ;
75395   Dali::Toolkit::Slider *result = 0 ;
75396
75397   {
75398     try {
75399       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
75400     } catch (std::out_of_range& e) {
75401       {
75402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75403       };
75404     } catch (std::exception& e) {
75405       {
75406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75407       };
75408     } catch (...) {
75409       {
75410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75411       };
75412     }
75413   }
75414   jresult = (void *)result;
75415   return jresult;
75416 }
75417
75418
75419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
75420   void * jresult ;
75421   Dali::Toolkit::Slider *arg1 = 0 ;
75422   Dali::Toolkit::Slider *result = 0 ;
75423
75424   arg1 = (Dali::Toolkit::Slider *)jarg1;
75425   if (!arg1) {
75426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75427     return 0;
75428   }
75429   {
75430     try {
75431       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
75432     } catch (std::out_of_range& e) {
75433       {
75434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75435       };
75436     } catch (std::exception& e) {
75437       {
75438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75439       };
75440     } catch (...) {
75441       {
75442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75443       };
75444     }
75445   }
75446   jresult = (void *)result;
75447   return jresult;
75448 }
75449
75450
75451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
75452   void * jresult ;
75453   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75454   Dali::Toolkit::Slider *arg2 = 0 ;
75455   Dali::Toolkit::Slider *result = 0 ;
75456
75457   arg1 = (Dali::Toolkit::Slider *)jarg1;
75458   arg2 = (Dali::Toolkit::Slider *)jarg2;
75459   if (!arg2) {
75460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
75461     return 0;
75462   }
75463   {
75464     try {
75465       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
75466     } catch (std::out_of_range& e) {
75467       {
75468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75469       };
75470     } catch (std::exception& e) {
75471       {
75472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75473       };
75474     } catch (...) {
75475       {
75476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75477       };
75478     }
75479   }
75480   jresult = (void *)result;
75481   return jresult;
75482 }
75483
75484
75485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
75486   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75487
75488   arg1 = (Dali::Toolkit::Slider *)jarg1;
75489   {
75490     try {
75491       delete arg1;
75492     } catch (std::out_of_range& e) {
75493       {
75494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75495       };
75496     } catch (std::exception& e) {
75497       {
75498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75499       };
75500     } catch (...) {
75501       {
75502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75503       };
75504     }
75505   }
75506 }
75507
75508
75509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
75510   void * jresult ;
75511   Dali::BaseHandle arg1 ;
75512   Dali::BaseHandle *argp1 ;
75513   Dali::Toolkit::Slider result;
75514
75515   argp1 = (Dali::BaseHandle *)jarg1;
75516   if (!argp1) {
75517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75518     return 0;
75519   }
75520   arg1 = *argp1;
75521   {
75522     try {
75523       result = Dali::Toolkit::Slider::DownCast(arg1);
75524     } catch (std::out_of_range& e) {
75525       {
75526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (std::exception& e) {
75529       {
75530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75531       };
75532     } catch (...) {
75533       {
75534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75535       };
75536     }
75537   }
75538   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
75539   return jresult;
75540 }
75541
75542
75543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
75544   void * jresult ;
75545   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75546   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75547
75548   arg1 = (Dali::Toolkit::Slider *)jarg1;
75549   {
75550     try {
75551       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
75552     } catch (std::out_of_range& e) {
75553       {
75554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75555       };
75556     } catch (std::exception& e) {
75557       {
75558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75559       };
75560     } catch (...) {
75561       {
75562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75563       };
75564     }
75565   }
75566   jresult = (void *)result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
75572   void * jresult ;
75573   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75574   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
75575
75576   arg1 = (Dali::Toolkit::Slider *)jarg1;
75577   {
75578     try {
75579       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
75580     } catch (std::out_of_range& e) {
75581       {
75582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75583       };
75584     } catch (std::exception& e) {
75585       {
75586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75587       };
75588     } catch (...) {
75589       {
75590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75591       };
75592     }
75593   }
75594   jresult = (void *)result;
75595   return jresult;
75596 }
75597
75598
75599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
75600   void * jresult ;
75601   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
75602   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
75603
75604   arg1 = (Dali::Toolkit::Slider *)jarg1;
75605   {
75606     try {
75607       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
75608     } catch (std::out_of_range& e) {
75609       {
75610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75611       };
75612     } catch (std::exception& e) {
75613       {
75614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75615       };
75616     } catch (...) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75619       };
75620     }
75621   }
75622   jresult = (void *)result;
75623   return jresult;
75624 }
75625
75626
75627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
75628   int jresult ;
75629   int result;
75630
75631   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
75632   jresult = (int)result;
75633   return jresult;
75634 }
75635
75636
75637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
75638   int jresult ;
75639   int result;
75640
75641   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
75642   jresult = (int)result;
75643   return jresult;
75644 }
75645
75646
75647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
75648   int jresult ;
75649   int result;
75650
75651   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
75652   jresult = (int)result;
75653   return jresult;
75654 }
75655
75656
75657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
75658   int jresult ;
75659   int result;
75660
75661   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
75662   jresult = (int)result;
75663   return jresult;
75664 }
75665
75666
75667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
75668   void * jresult ;
75669   Dali::Toolkit::VideoView::Property *result = 0 ;
75670
75671   {
75672     try {
75673       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
75674     } catch (std::out_of_range& e) {
75675       {
75676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75677       };
75678     } catch (std::exception& e) {
75679       {
75680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75681       };
75682     } catch (...) {
75683       {
75684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75685       };
75686     }
75687   }
75688   jresult = (void *)result;
75689   return jresult;
75690 }
75691
75692
75693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
75694   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
75695
75696   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
75697   {
75698     try {
75699       delete arg1;
75700     } catch (std::out_of_range& e) {
75701       {
75702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75703       };
75704     } catch (std::exception& e) {
75705       {
75706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75707       };
75708     } catch (...) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75711       };
75712     }
75713   }
75714 }
75715
75716
75717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
75718   void * jresult ;
75719   Dali::Toolkit::VideoView result;
75720
75721   {
75722     try {
75723       result = Dali::Toolkit::VideoView::New();
75724     } catch (std::out_of_range& e) {
75725       {
75726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75727       };
75728     } catch (std::exception& e) {
75729       {
75730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75731       };
75732     } catch (...) {
75733       {
75734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75735       };
75736     }
75737   }
75738   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75739   return jresult;
75740 }
75741
75742
75743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
75744   void * jresult ;
75745   std::string *arg1 = 0 ;
75746   Dali::Toolkit::VideoView result;
75747
75748   if (!jarg1) {
75749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75750     return 0;
75751   }
75752   std::string arg1_str(jarg1);
75753   arg1 = &arg1_str;
75754   {
75755     try {
75756       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
75757     } catch (std::out_of_range& e) {
75758       {
75759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75760       };
75761     } catch (std::exception& e) {
75762       {
75763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75764       };
75765     } catch (...) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75768       };
75769     }
75770   }
75771   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75772
75773   //argout typemap for const std::string&
75774
75775   return jresult;
75776 }
75777
75778
75779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
75780   void * jresult ;
75781   Dali::Toolkit::VideoView *result = 0 ;
75782
75783   {
75784     try {
75785       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
75786     } catch (std::out_of_range& e) {
75787       {
75788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75789       };
75790     } catch (std::exception& e) {
75791       {
75792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75793       };
75794     } catch (...) {
75795       {
75796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75797       };
75798     }
75799   }
75800   jresult = (void *)result;
75801   return jresult;
75802 }
75803
75804
75805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
75806   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75807
75808   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75809   {
75810     try {
75811       delete arg1;
75812     } catch (std::out_of_range& e) {
75813       {
75814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75815       };
75816     } catch (std::exception& e) {
75817       {
75818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75819       };
75820     } catch (...) {
75821       {
75822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75823       };
75824     }
75825   }
75826 }
75827
75828
75829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
75830   void * jresult ;
75831   Dali::Toolkit::VideoView *arg1 = 0 ;
75832   Dali::Toolkit::VideoView *result = 0 ;
75833
75834   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75835   if (!arg1) {
75836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75837     return 0;
75838   }
75839   {
75840     try {
75841       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (...) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75853       };
75854     }
75855   }
75856   jresult = (void *)result;
75857   return jresult;
75858 }
75859
75860
75861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
75862   void * jresult ;
75863   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75864   Dali::Toolkit::VideoView *arg2 = 0 ;
75865   Dali::Toolkit::VideoView *result = 0 ;
75866
75867   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75868   arg2 = (Dali::Toolkit::VideoView *)jarg2;
75869   if (!arg2) {
75870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
75871     return 0;
75872   }
75873   {
75874     try {
75875       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
75876     } catch (std::out_of_range& e) {
75877       {
75878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75879       };
75880     } catch (std::exception& e) {
75881       {
75882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75883       };
75884     } catch (...) {
75885       {
75886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75887       };
75888     }
75889   }
75890   jresult = (void *)result;
75891   return jresult;
75892 }
75893
75894
75895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
75896   void * jresult ;
75897   Dali::BaseHandle arg1 ;
75898   Dali::BaseHandle *argp1 ;
75899   Dali::Toolkit::VideoView result;
75900
75901   argp1 = (Dali::BaseHandle *)jarg1;
75902   if (!argp1) {
75903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75904     return 0;
75905   }
75906   arg1 = *argp1;
75907   {
75908     try {
75909       result = Dali::Toolkit::VideoView::DownCast(arg1);
75910     } catch (std::out_of_range& e) {
75911       {
75912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75913       };
75914     } catch (std::exception& e) {
75915       {
75916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75917       };
75918     } catch (...) {
75919       {
75920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75921       };
75922     }
75923   }
75924   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
75925   return jresult;
75926 }
75927
75928
75929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
75930   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75931
75932   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75933   {
75934     try {
75935       (arg1)->Play();
75936     } catch (std::out_of_range& e) {
75937       {
75938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75939       };
75940     } catch (std::exception& e) {
75941       {
75942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75947       };
75948     }
75949   }
75950 }
75951
75952
75953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
75954   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75955
75956   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75957   {
75958     try {
75959       (arg1)->Pause();
75960     } catch (std::out_of_range& e) {
75961       {
75962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75963       };
75964     } catch (std::exception& e) {
75965       {
75966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75967       };
75968     } catch (...) {
75969       {
75970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75971       };
75972     }
75973   }
75974 }
75975
75976
75977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
75978   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
75979
75980   arg1 = (Dali::Toolkit::VideoView *)jarg1;
75981   {
75982     try {
75983       (arg1)->Stop();
75984     } catch (std::out_of_range& e) {
75985       {
75986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75987       };
75988     } catch (std::exception& e) {
75989       {
75990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75991       };
75992     } catch (...) {
75993       {
75994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75995       };
75996     }
75997   }
75998 }
75999
76000
76001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
76002   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
76003   int arg2 ;
76004
76005   arg1 = (Dali::Toolkit::VideoView *)jarg1;
76006   arg2 = (int)jarg2;
76007   {
76008     try {
76009       (arg1)->Forward(arg2);
76010     } catch (std::out_of_range& e) {
76011       {
76012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76013       };
76014     } catch (std::exception& e) {
76015       {
76016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76017       };
76018     } catch (...) {
76019       {
76020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76021       };
76022     }
76023   }
76024 }
76025
76026
76027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
76028   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
76029   int arg2 ;
76030
76031   arg1 = (Dali::Toolkit::VideoView *)jarg1;
76032   arg2 = (int)jarg2;
76033   {
76034     try {
76035       (arg1)->Backward(arg2);
76036     } catch (std::out_of_range& e) {
76037       {
76038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76039       };
76040     } catch (std::exception& e) {
76041       {
76042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76043       };
76044     } catch (...) {
76045       {
76046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76047       };
76048     }
76049   }
76050 }
76051
76052
76053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
76054   void * jresult ;
76055   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
76056   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
76057
76058   arg1 = (Dali::Toolkit::VideoView *)jarg1;
76059   {
76060     try {
76061       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
76062     } catch (std::out_of_range& e) {
76063       {
76064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (std::exception& e) {
76067       {
76068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76069       };
76070     } catch (...) {
76071       {
76072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76073       };
76074     }
76075   }
76076   jresult = (void *)result;
76077   return jresult;
76078 }
76079
76080
76081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
76082   int jresult ;
76083   int result;
76084
76085   result = (int)Dali::Toolkit::Popup::Property::TITLE;
76086   jresult = (int)result;
76087   return jresult;
76088 }
76089
76090
76091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
76092   int jresult ;
76093   int result;
76094
76095   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
76096   jresult = (int)result;
76097   return jresult;
76098 }
76099
76100
76101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
76102   int jresult ;
76103   int result;
76104
76105   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
76106   jresult = (int)result;
76107   return jresult;
76108 }
76109
76110
76111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
76112   int jresult ;
76113   int result;
76114
76115   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
76116   jresult = (int)result;
76117   return jresult;
76118 }
76119
76120
76121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
76122   int jresult ;
76123   int result;
76124
76125   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
76126   jresult = (int)result;
76127   return jresult;
76128 }
76129
76130
76131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
76132   int jresult ;
76133   int result;
76134
76135   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
76136   jresult = (int)result;
76137   return jresult;
76138 }
76139
76140
76141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
76142   int jresult ;
76143   int result;
76144
76145   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
76146   jresult = (int)result;
76147   return jresult;
76148 }
76149
76150
76151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
76152   int jresult ;
76153   int result;
76154
76155   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
76156   jresult = (int)result;
76157   return jresult;
76158 }
76159
76160
76161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
76162   int jresult ;
76163   int result;
76164
76165   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
76166   jresult = (int)result;
76167   return jresult;
76168 }
76169
76170
76171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
76172   int jresult ;
76173   int result;
76174
76175   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
76176   jresult = (int)result;
76177   return jresult;
76178 }
76179
76180
76181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
76182   int jresult ;
76183   int result;
76184
76185   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
76186   jresult = (int)result;
76187   return jresult;
76188 }
76189
76190
76191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
76192   int jresult ;
76193   int result;
76194
76195   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
76196   jresult = (int)result;
76197   return jresult;
76198 }
76199
76200
76201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
76202   int jresult ;
76203   int result;
76204
76205   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
76206   jresult = (int)result;
76207   return jresult;
76208 }
76209
76210
76211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
76212   int jresult ;
76213   int result;
76214
76215   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
76216   jresult = (int)result;
76217   return jresult;
76218 }
76219
76220
76221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
76222   int jresult ;
76223   int result;
76224
76225   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
76226   jresult = (int)result;
76227   return jresult;
76228 }
76229
76230
76231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
76232   int jresult ;
76233   int result;
76234
76235   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
76236   jresult = (int)result;
76237   return jresult;
76238 }
76239
76240
76241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
76242   int jresult ;
76243   int result;
76244
76245   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
76246   jresult = (int)result;
76247   return jresult;
76248 }
76249
76250
76251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
76252   int jresult ;
76253   int result;
76254
76255   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
76256   jresult = (int)result;
76257   return jresult;
76258 }
76259
76260
76261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
76262   int jresult ;
76263   int result;
76264
76265   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
76266   jresult = (int)result;
76267   return jresult;
76268 }
76269
76270
76271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
76272   int jresult ;
76273   int result;
76274
76275   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
76276   jresult = (int)result;
76277   return jresult;
76278 }
76279
76280
76281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
76282   int jresult ;
76283   int result;
76284
76285   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
76286   jresult = (int)result;
76287   return jresult;
76288 }
76289
76290
76291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
76292   void * jresult ;
76293   Dali::Toolkit::Popup::Property *result = 0 ;
76294
76295   {
76296     try {
76297       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
76298     } catch (std::out_of_range& e) {
76299       {
76300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76301       };
76302     } catch (std::exception& e) {
76303       {
76304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76305       };
76306     } catch (...) {
76307       {
76308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76309       };
76310     }
76311   }
76312   jresult = (void *)result;
76313   return jresult;
76314 }
76315
76316
76317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
76318   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
76319
76320   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
76321   {
76322     try {
76323       delete arg1;
76324     } catch (std::out_of_range& e) {
76325       {
76326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76327       };
76328     } catch (std::exception& e) {
76329       {
76330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (...) {
76333       {
76334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76335       };
76336     }
76337   }
76338 }
76339
76340
76341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
76342   void * jresult ;
76343   Dali::Toolkit::Popup *result = 0 ;
76344
76345   {
76346     try {
76347       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
76348     } catch (std::out_of_range& e) {
76349       {
76350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (std::exception& e) {
76353       {
76354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76355       };
76356     } catch (...) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76359       };
76360     }
76361   }
76362   jresult = (void *)result;
76363   return jresult;
76364 }
76365
76366
76367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
76368   void * jresult ;
76369   Dali::Toolkit::Popup result;
76370
76371   {
76372     try {
76373       result = Dali::Toolkit::Popup::New();
76374     } catch (std::out_of_range& e) {
76375       {
76376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76377       };
76378     } catch (std::exception& e) {
76379       {
76380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76381       };
76382     } catch (...) {
76383       {
76384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76385       };
76386     }
76387   }
76388   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76389   return jresult;
76390 }
76391
76392
76393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
76394   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76395
76396   arg1 = (Dali::Toolkit::Popup *)jarg1;
76397   {
76398     try {
76399       delete arg1;
76400     } catch (std::out_of_range& e) {
76401       {
76402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76403       };
76404     } catch (std::exception& e) {
76405       {
76406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76407       };
76408     } catch (...) {
76409       {
76410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76411       };
76412     }
76413   }
76414 }
76415
76416
76417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
76418   void * jresult ;
76419   Dali::Toolkit::Popup *arg1 = 0 ;
76420   Dali::Toolkit::Popup *result = 0 ;
76421
76422   arg1 = (Dali::Toolkit::Popup *)jarg1;
76423   if (!arg1) {
76424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76425     return 0;
76426   }
76427   {
76428     try {
76429       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
76430     } catch (std::out_of_range& e) {
76431       {
76432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76433       };
76434     } catch (std::exception& e) {
76435       {
76436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76437       };
76438     } catch (...) {
76439       {
76440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76441       };
76442     }
76443   }
76444   jresult = (void *)result;
76445   return jresult;
76446 }
76447
76448
76449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
76450   void * jresult ;
76451   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76452   Dali::Toolkit::Popup *arg2 = 0 ;
76453   Dali::Toolkit::Popup *result = 0 ;
76454
76455   arg1 = (Dali::Toolkit::Popup *)jarg1;
76456   arg2 = (Dali::Toolkit::Popup *)jarg2;
76457   if (!arg2) {
76458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
76459     return 0;
76460   }
76461   {
76462     try {
76463       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
76464     } catch (std::out_of_range& e) {
76465       {
76466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76467       };
76468     } catch (std::exception& e) {
76469       {
76470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76471       };
76472     } catch (...) {
76473       {
76474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76475       };
76476     }
76477   }
76478   jresult = (void *)result;
76479   return jresult;
76480 }
76481
76482
76483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
76484   void * jresult ;
76485   Dali::BaseHandle arg1 ;
76486   Dali::BaseHandle *argp1 ;
76487   Dali::Toolkit::Popup result;
76488
76489   argp1 = (Dali::BaseHandle *)jarg1;
76490   if (!argp1) {
76491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76492     return 0;
76493   }
76494   arg1 = *argp1;
76495   {
76496     try {
76497       result = Dali::Toolkit::Popup::DownCast(arg1);
76498     } catch (std::out_of_range& e) {
76499       {
76500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76501       };
76502     } catch (std::exception& e) {
76503       {
76504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76505       };
76506     } catch (...) {
76507       {
76508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76509       };
76510     }
76511   }
76512   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
76513   return jresult;
76514 }
76515
76516
76517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
76518   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76519   Dali::Actor arg2 ;
76520   Dali::Actor *argp2 ;
76521
76522   arg1 = (Dali::Toolkit::Popup *)jarg1;
76523   argp2 = (Dali::Actor *)jarg2;
76524   if (!argp2) {
76525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76526     return ;
76527   }
76528   arg2 = *argp2;
76529   {
76530     try {
76531       (arg1)->SetTitle(arg2);
76532     } catch (std::out_of_range& e) {
76533       {
76534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76535       };
76536     } catch (std::exception& e) {
76537       {
76538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76539       };
76540     } catch (...) {
76541       {
76542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76543       };
76544     }
76545   }
76546 }
76547
76548
76549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
76550   void * jresult ;
76551   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76552   Dali::Actor result;
76553
76554   arg1 = (Dali::Toolkit::Popup *)jarg1;
76555   {
76556     try {
76557       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
76558     } catch (std::out_of_range& e) {
76559       {
76560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76561       };
76562     } catch (std::exception& e) {
76563       {
76564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76565       };
76566     } catch (...) {
76567       {
76568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76569       };
76570     }
76571   }
76572   jresult = new Dali::Actor((const Dali::Actor &)result);
76573   return jresult;
76574 }
76575
76576
76577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
76578   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76579   Dali::Actor arg2 ;
76580   Dali::Actor *argp2 ;
76581
76582   arg1 = (Dali::Toolkit::Popup *)jarg1;
76583   argp2 = (Dali::Actor *)jarg2;
76584   if (!argp2) {
76585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76586     return ;
76587   }
76588   arg2 = *argp2;
76589   {
76590     try {
76591       (arg1)->SetContent(arg2);
76592     } catch (std::out_of_range& e) {
76593       {
76594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76595       };
76596     } catch (std::exception& e) {
76597       {
76598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76599       };
76600     } catch (...) {
76601       {
76602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76603       };
76604     }
76605   }
76606 }
76607
76608
76609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
76610   void * jresult ;
76611   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76612   Dali::Actor result;
76613
76614   arg1 = (Dali::Toolkit::Popup *)jarg1;
76615   {
76616     try {
76617       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
76618     } catch (std::out_of_range& e) {
76619       {
76620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76621       };
76622     } catch (std::exception& e) {
76623       {
76624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76625       };
76626     } catch (...) {
76627       {
76628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76629       };
76630     }
76631   }
76632   jresult = new Dali::Actor((const Dali::Actor &)result);
76633   return jresult;
76634 }
76635
76636
76637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
76638   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76639   Dali::Actor arg2 ;
76640   Dali::Actor *argp2 ;
76641
76642   arg1 = (Dali::Toolkit::Popup *)jarg1;
76643   argp2 = (Dali::Actor *)jarg2;
76644   if (!argp2) {
76645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76646     return ;
76647   }
76648   arg2 = *argp2;
76649   {
76650     try {
76651       (arg1)->SetFooter(arg2);
76652     } catch (std::out_of_range& e) {
76653       {
76654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (std::exception& e) {
76657       {
76658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76659       };
76660     } catch (...) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76663       };
76664     }
76665   }
76666 }
76667
76668
76669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
76670   void * jresult ;
76671   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76672   Dali::Actor result;
76673
76674   arg1 = (Dali::Toolkit::Popup *)jarg1;
76675   {
76676     try {
76677       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
76678     } catch (std::out_of_range& e) {
76679       {
76680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (std::exception& e) {
76683       {
76684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76685       };
76686     } catch (...) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76689       };
76690     }
76691   }
76692   jresult = new Dali::Actor((const Dali::Actor &)result);
76693   return jresult;
76694 }
76695
76696
76697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
76698   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76699   Dali::Toolkit::Popup::DisplayState arg2 ;
76700
76701   arg1 = (Dali::Toolkit::Popup *)jarg1;
76702   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
76703   {
76704     try {
76705       (arg1)->SetDisplayState(arg2);
76706     } catch (std::out_of_range& e) {
76707       {
76708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76709       };
76710     } catch (std::exception& e) {
76711       {
76712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76713       };
76714     } catch (...) {
76715       {
76716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76717       };
76718     }
76719   }
76720 }
76721
76722
76723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
76724   int jresult ;
76725   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76726   Dali::Toolkit::Popup::DisplayState result;
76727
76728   arg1 = (Dali::Toolkit::Popup *)jarg1;
76729   {
76730     try {
76731       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
76732     } catch (std::out_of_range& e) {
76733       {
76734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76735       };
76736     } catch (std::exception& e) {
76737       {
76738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76739       };
76740     } catch (...) {
76741       {
76742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76743       };
76744     }
76745   }
76746   jresult = (int)result;
76747   return jresult;
76748 }
76749
76750
76751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
76752   void * jresult ;
76753   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76754   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
76755
76756   arg1 = (Dali::Toolkit::Popup *)jarg1;
76757   {
76758     try {
76759       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
76760     } catch (std::out_of_range& e) {
76761       {
76762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76763       };
76764     } catch (std::exception& e) {
76765       {
76766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76767       };
76768     } catch (...) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76771       };
76772     }
76773   }
76774   jresult = (void *)result;
76775   return jresult;
76776 }
76777
76778
76779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
76780   void * jresult ;
76781   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76782   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76783
76784   arg1 = (Dali::Toolkit::Popup *)jarg1;
76785   {
76786     try {
76787       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
76788     } catch (std::out_of_range& e) {
76789       {
76790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76791       };
76792     } catch (std::exception& e) {
76793       {
76794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76795       };
76796     } catch (...) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76799       };
76800     }
76801   }
76802   jresult = (void *)result;
76803   return jresult;
76804 }
76805
76806
76807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
76808   void * jresult ;
76809   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76810   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76811
76812   arg1 = (Dali::Toolkit::Popup *)jarg1;
76813   {
76814     try {
76815       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
76816     } catch (std::out_of_range& e) {
76817       {
76818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76819       };
76820     } catch (std::exception& e) {
76821       {
76822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76823       };
76824     } catch (...) {
76825       {
76826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76827       };
76828     }
76829   }
76830   jresult = (void *)result;
76831   return jresult;
76832 }
76833
76834
76835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
76836   void * jresult ;
76837   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76838   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76839
76840   arg1 = (Dali::Toolkit::Popup *)jarg1;
76841   {
76842     try {
76843       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
76844     } catch (std::out_of_range& e) {
76845       {
76846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76847       };
76848     } catch (std::exception& e) {
76849       {
76850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76851       };
76852     } catch (...) {
76853       {
76854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76855       };
76856     }
76857   }
76858   jresult = (void *)result;
76859   return jresult;
76860 }
76861
76862
76863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
76864   void * jresult ;
76865   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
76866   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
76867
76868   arg1 = (Dali::Toolkit::Popup *)jarg1;
76869   {
76870     try {
76871       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
76872     } catch (std::out_of_range& e) {
76873       {
76874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76875       };
76876     } catch (std::exception& e) {
76877       {
76878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76879       };
76880     } catch (...) {
76881       {
76882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76883       };
76884     }
76885   }
76886   jresult = (void *)result;
76887   return jresult;
76888 }
76889
76890
76891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
76892   int jresult ;
76893   int result;
76894
76895   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
76896   jresult = (int)result;
76897   return jresult;
76898 }
76899
76900
76901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
76902   int jresult ;
76903   int result;
76904
76905   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
76906   jresult = (int)result;
76907   return jresult;
76908 }
76909
76910
76911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
76912   int jresult ;
76913   int result;
76914
76915   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
76916   jresult = (int)result;
76917   return jresult;
76918 }
76919
76920
76921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
76922   int jresult ;
76923   int result;
76924
76925   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
76926   jresult = (int)result;
76927   return jresult;
76928 }
76929
76930
76931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
76932   int jresult ;
76933   int result;
76934
76935   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
76936   jresult = (int)result;
76937   return jresult;
76938 }
76939
76940
76941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
76942   int jresult ;
76943   int result;
76944
76945   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
76946   jresult = (int)result;
76947   return jresult;
76948 }
76949
76950
76951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
76952   int jresult ;
76953   int result;
76954
76955   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
76956   jresult = (int)result;
76957   return jresult;
76958 }
76959
76960
76961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
76962   int jresult ;
76963   int result;
76964
76965   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
76966   jresult = (int)result;
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
76972   int jresult ;
76973   int result;
76974
76975   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
76976   jresult = (int)result;
76977   return jresult;
76978 }
76979
76980
76981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
76982   void * jresult ;
76983   Dali::Toolkit::ProgressBar::Property *result = 0 ;
76984
76985   {
76986     try {
76987       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
76988     } catch (std::out_of_range& e) {
76989       {
76990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76991       };
76992     } catch (std::exception& e) {
76993       {
76994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76995       };
76996     } catch (...) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76999       };
77000     }
77001   }
77002   jresult = (void *)result;
77003   return jresult;
77004 }
77005
77006
77007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
77008   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
77009
77010   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
77011   {
77012     try {
77013       delete arg1;
77014     } catch (std::out_of_range& e) {
77015       {
77016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77017       };
77018     } catch (std::exception& e) {
77019       {
77020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77021       };
77022     } catch (...) {
77023       {
77024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77025       };
77026     }
77027   }
77028 }
77029
77030
77031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
77032   void * jresult ;
77033   Dali::Toolkit::ProgressBar result;
77034
77035   {
77036     try {
77037       result = Dali::Toolkit::ProgressBar::New();
77038     } catch (std::out_of_range& e) {
77039       {
77040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77041       };
77042     } catch (std::exception& e) {
77043       {
77044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77045       };
77046     } catch (...) {
77047       {
77048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77049       };
77050     }
77051   }
77052   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77053   return jresult;
77054 }
77055
77056
77057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
77058   void * jresult ;
77059   Dali::Toolkit::ProgressBar *result = 0 ;
77060
77061   {
77062     try {
77063       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
77064     } catch (std::out_of_range& e) {
77065       {
77066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77067       };
77068     } catch (std::exception& e) {
77069       {
77070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77071       };
77072     } catch (...) {
77073       {
77074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77075       };
77076     }
77077   }
77078   jresult = (void *)result;
77079   return jresult;
77080 }
77081
77082
77083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
77084   void * jresult ;
77085   Dali::Toolkit::ProgressBar *arg1 = 0 ;
77086   Dali::Toolkit::ProgressBar *result = 0 ;
77087
77088   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77089   if (!arg1) {
77090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
77091     return 0;
77092   }
77093   {
77094     try {
77095       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
77096     } catch (std::out_of_range& e) {
77097       {
77098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77099       };
77100     } catch (std::exception& e) {
77101       {
77102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77103       };
77104     } catch (...) {
77105       {
77106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77107       };
77108     }
77109   }
77110   jresult = (void *)result;
77111   return jresult;
77112 }
77113
77114
77115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
77116   void * jresult ;
77117   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77118   Dali::Toolkit::ProgressBar *arg2 = 0 ;
77119   Dali::Toolkit::ProgressBar *result = 0 ;
77120
77121   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77122   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
77123   if (!arg2) {
77124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
77125     return 0;
77126   }
77127   {
77128     try {
77129       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
77130     } catch (std::out_of_range& e) {
77131       {
77132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77133       };
77134     } catch (std::exception& e) {
77135       {
77136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77137       };
77138     } catch (...) {
77139       {
77140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77141       };
77142     }
77143   }
77144   jresult = (void *)result;
77145   return jresult;
77146 }
77147
77148
77149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
77150   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77151
77152   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77153   {
77154     try {
77155       delete arg1;
77156     } catch (std::out_of_range& e) {
77157       {
77158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77159       };
77160     } catch (std::exception& e) {
77161       {
77162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77163       };
77164     } catch (...) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77167       };
77168     }
77169   }
77170 }
77171
77172
77173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
77174   void * jresult ;
77175   Dali::BaseHandle arg1 ;
77176   Dali::BaseHandle *argp1 ;
77177   Dali::Toolkit::ProgressBar result;
77178
77179   argp1 = (Dali::BaseHandle *)jarg1;
77180   if (!argp1) {
77181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77182     return 0;
77183   }
77184   arg1 = *argp1;
77185   {
77186     try {
77187       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
77188     } catch (std::out_of_range& e) {
77189       {
77190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77191       };
77192     } catch (std::exception& e) {
77193       {
77194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77195       };
77196     } catch (...) {
77197       {
77198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77199       };
77200     }
77201   }
77202   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
77203   return jresult;
77204 }
77205
77206
77207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
77208   void * jresult ;
77209   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
77210   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
77211
77212   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
77213   {
77214     try {
77215       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77216     } catch (std::out_of_range& e) {
77217       {
77218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77219       };
77220     } catch (std::exception& e) {
77221       {
77222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77223       };
77224     } catch (...) {
77225       {
77226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77227       };
77228     }
77229   }
77230   jresult = (void *)result;
77231   return jresult;
77232 }
77233
77234
77235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
77236   void * jresult ;
77237   Dali::Toolkit::GaussianBlurView *result = 0 ;
77238
77239   {
77240     try {
77241       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
77242     } catch (std::out_of_range& e) {
77243       {
77244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77245       };
77246     } catch (std::exception& e) {
77247       {
77248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77249       };
77250     } catch (...) {
77251       {
77252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77253       };
77254     }
77255   }
77256   jresult = (void *)result;
77257   return jresult;
77258 }
77259
77260
77261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
77262   void * jresult ;
77263   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
77264   Dali::Toolkit::GaussianBlurView *result = 0 ;
77265
77266   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77267   if (!arg1) {
77268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77269     return 0;
77270   }
77271   {
77272     try {
77273       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
77274     } catch (std::out_of_range& e) {
77275       {
77276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77277       };
77278     } catch (std::exception& e) {
77279       {
77280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77281       };
77282     } catch (...) {
77283       {
77284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77285       };
77286     }
77287   }
77288   jresult = (void *)result;
77289   return jresult;
77290 }
77291
77292
77293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
77294   void * jresult ;
77295   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77296   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
77297   Dali::Toolkit::GaussianBlurView *result = 0 ;
77298
77299   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77300   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
77301   if (!arg2) {
77302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
77303     return 0;
77304   }
77305   {
77306     try {
77307       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
77308     } catch (std::out_of_range& e) {
77309       {
77310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77311       };
77312     } catch (std::exception& e) {
77313       {
77314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77315       };
77316     } catch (...) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77319       };
77320     }
77321   }
77322   jresult = (void *)result;
77323   return jresult;
77324 }
77325
77326
77327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
77328   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77329
77330   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77331   {
77332     try {
77333       delete arg1;
77334     } catch (std::out_of_range& e) {
77335       {
77336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77337       };
77338     } catch (std::exception& e) {
77339       {
77340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77341       };
77342     } catch (...) {
77343       {
77344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77345       };
77346     }
77347   }
77348 }
77349
77350
77351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
77352   void * jresult ;
77353   Dali::BaseHandle arg1 ;
77354   Dali::BaseHandle *argp1 ;
77355   Dali::Toolkit::GaussianBlurView result;
77356
77357   argp1 = (Dali::BaseHandle *)jarg1;
77358   if (!argp1) {
77359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77360     return 0;
77361   }
77362   arg1 = *argp1;
77363   {
77364     try {
77365       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77373       };
77374     } catch (...) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77377       };
77378     }
77379   }
77380   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77381   return jresult;
77382 }
77383
77384
77385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
77386   void * jresult ;
77387   Dali::Toolkit::GaussianBlurView result;
77388
77389   {
77390     try {
77391       result = Dali::Toolkit::GaussianBlurView::New();
77392     } catch (std::out_of_range& e) {
77393       {
77394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77395       };
77396     } catch (std::exception& e) {
77397       {
77398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77399       };
77400     } catch (...) {
77401       {
77402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77403       };
77404     }
77405   }
77406   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77407   return jresult;
77408 }
77409
77410
77411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
77412   void * jresult ;
77413   unsigned int arg1 ;
77414   float arg2 ;
77415   Dali::Pixel::Format arg3 ;
77416   float arg4 ;
77417   float arg5 ;
77418   bool arg6 ;
77419   Dali::Toolkit::GaussianBlurView result;
77420
77421   arg1 = (unsigned int)jarg1;
77422   arg2 = (float)jarg2;
77423   arg3 = (Dali::Pixel::Format)jarg3;
77424   arg4 = (float)jarg4;
77425   arg5 = (float)jarg5;
77426   arg6 = jarg6 ? true : false;
77427   {
77428     try {
77429       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
77430     } catch (std::out_of_range& e) {
77431       {
77432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77433       };
77434     } catch (std::exception& e) {
77435       {
77436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77437       };
77438     } catch (...) {
77439       {
77440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77441       };
77442     }
77443   }
77444   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77445   return jresult;
77446 }
77447
77448
77449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
77450   void * jresult ;
77451   unsigned int arg1 ;
77452   float arg2 ;
77453   Dali::Pixel::Format arg3 ;
77454   float arg4 ;
77455   float arg5 ;
77456   Dali::Toolkit::GaussianBlurView result;
77457
77458   arg1 = (unsigned int)jarg1;
77459   arg2 = (float)jarg2;
77460   arg3 = (Dali::Pixel::Format)jarg3;
77461   arg4 = (float)jarg4;
77462   arg5 = (float)jarg5;
77463   {
77464     try {
77465       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
77466     } catch (std::out_of_range& e) {
77467       {
77468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77469       };
77470     } catch (std::exception& e) {
77471       {
77472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77473       };
77474     } catch (...) {
77475       {
77476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77477       };
77478     }
77479   }
77480   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
77481   return jresult;
77482 }
77483
77484
77485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
77486   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77487   Dali::Actor arg2 ;
77488   Dali::Actor *argp2 ;
77489
77490   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77491   argp2 = (Dali::Actor *)jarg2;
77492   if (!argp2) {
77493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77494     return ;
77495   }
77496   arg2 = *argp2;
77497   {
77498     try {
77499       (arg1)->Add(arg2);
77500     } catch (std::out_of_range& e) {
77501       {
77502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77503       };
77504     } catch (std::exception& e) {
77505       {
77506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77507       };
77508     } catch (...) {
77509       {
77510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77511       };
77512     }
77513   }
77514 }
77515
77516
77517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
77518   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77519   Dali::Actor arg2 ;
77520   Dali::Actor *argp2 ;
77521
77522   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77523   argp2 = (Dali::Actor *)jarg2;
77524   if (!argp2) {
77525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77526     return ;
77527   }
77528   arg2 = *argp2;
77529   {
77530     try {
77531       (arg1)->Remove(arg2);
77532     } catch (std::out_of_range& e) {
77533       {
77534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77535       };
77536     } catch (std::exception& e) {
77537       {
77538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77539       };
77540     } catch (...) {
77541       {
77542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77543       };
77544     }
77545   }
77546 }
77547
77548
77549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
77550   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77551
77552   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77553   {
77554     try {
77555       (arg1)->Activate();
77556     } catch (std::out_of_range& e) {
77557       {
77558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77559       };
77560     } catch (std::exception& e) {
77561       {
77562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77563       };
77564     } catch (...) {
77565       {
77566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77567       };
77568     }
77569   }
77570 }
77571
77572
77573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
77574   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77575
77576   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77577   {
77578     try {
77579       (arg1)->ActivateOnce();
77580     } catch (std::out_of_range& e) {
77581       {
77582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77583       };
77584     } catch (std::exception& e) {
77585       {
77586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77587       };
77588     } catch (...) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77591       };
77592     }
77593   }
77594 }
77595
77596
77597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
77598   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77599
77600   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77601   {
77602     try {
77603       (arg1)->Deactivate();
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77611       };
77612     } catch (...) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77615       };
77616     }
77617   }
77618 }
77619
77620
77621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
77622   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77623   Dali::Image arg2 ;
77624   Dali::FrameBufferImage arg3 ;
77625   Dali::Image *argp2 ;
77626   Dali::FrameBufferImage *argp3 ;
77627
77628   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77629   argp2 = (Dali::Image *)jarg2;
77630   if (!argp2) {
77631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
77632     return ;
77633   }
77634   arg2 = *argp2;
77635   argp3 = (Dali::FrameBufferImage *)jarg3;
77636   if (!argp3) {
77637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
77638     return ;
77639   }
77640   arg3 = *argp3;
77641   {
77642     try {
77643       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77651       };
77652     } catch (...) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77655       };
77656     }
77657   }
77658 }
77659
77660
77661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
77662   int jresult ;
77663   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77664   Dali::Property::Index result;
77665
77666   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77667   {
77668     try {
77669       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
77670     } catch (std::out_of_range& e) {
77671       {
77672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77673       };
77674     } catch (std::exception& e) {
77675       {
77676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77677       };
77678     } catch (...) {
77679       {
77680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77681       };
77682     }
77683   }
77684   jresult = result;
77685   return jresult;
77686 }
77687
77688
77689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
77690   void * jresult ;
77691   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77692   Dali::FrameBufferImage result;
77693
77694   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77695   {
77696     try {
77697       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
77698     } catch (std::out_of_range& e) {
77699       {
77700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77701       };
77702     } catch (std::exception& e) {
77703       {
77704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77705       };
77706     } catch (...) {
77707       {
77708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77709       };
77710     }
77711   }
77712   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
77713   return jresult;
77714 }
77715
77716
77717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
77718   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77719   Dali::Vector4 *arg2 = 0 ;
77720
77721   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77722   arg2 = (Dali::Vector4 *)jarg2;
77723   if (!arg2) {
77724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
77725     return ;
77726   }
77727   {
77728     try {
77729       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
77730     } catch (std::out_of_range& e) {
77731       {
77732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77733       };
77734     } catch (std::exception& e) {
77735       {
77736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77737       };
77738     } catch (...) {
77739       {
77740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77741       };
77742     }
77743   }
77744 }
77745
77746
77747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
77748   void * jresult ;
77749   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77750   Dali::Vector4 result;
77751
77752   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77753   {
77754     try {
77755       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
77756     } catch (std::out_of_range& e) {
77757       {
77758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77759       };
77760     } catch (std::exception& e) {
77761       {
77762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77763       };
77764     } catch (...) {
77765       {
77766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77767       };
77768     }
77769   }
77770   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
77771   return jresult;
77772 }
77773
77774
77775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
77776   void * jresult ;
77777   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
77778   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
77779
77780   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
77781   {
77782     try {
77783       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
77784     } catch (std::out_of_range& e) {
77785       {
77786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77787       };
77788     } catch (std::exception& e) {
77789       {
77790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77791       };
77792     } catch (...) {
77793       {
77794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77795       };
77796     }
77797   }
77798   jresult = (void *)result;
77799   return jresult;
77800 }
77801
77802
77803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
77804   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77805
77806   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77807   {
77808     try {
77809       delete arg1;
77810     } catch (std::out_of_range& e) {
77811       {
77812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77813       };
77814     } catch (std::exception& e) {
77815       {
77816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77817       };
77818     } catch (...) {
77819       {
77820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77821       };
77822     }
77823   }
77824 }
77825
77826
77827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
77828   unsigned int jresult ;
77829   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77830   unsigned int result;
77831
77832   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77833   {
77834     try {
77835       result = (unsigned int)(arg1)->GetNumberOfPages();
77836     } catch (std::out_of_range& e) {
77837       {
77838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77839       };
77840     } catch (std::exception& e) {
77841       {
77842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77843       };
77844     } catch (...) {
77845       {
77846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77847       };
77848     }
77849   }
77850   jresult = result;
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
77856   void * jresult ;
77857   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
77858   unsigned int arg2 ;
77859   Dali::Texture result;
77860
77861   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
77862   arg2 = (unsigned int)jarg2;
77863   {
77864     try {
77865       result = (arg1)->NewPage(arg2);
77866     } catch (std::out_of_range& e) {
77867       {
77868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77869       };
77870     } catch (std::exception& e) {
77871       {
77872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77873       };
77874     } catch (...) {
77875       {
77876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77877       };
77878     }
77879   }
77880   jresult = new Dali::Texture((const Dali::Texture &)result);
77881   return jresult;
77882 }
77883
77884
77885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
77886   int jresult ;
77887   int result;
77888
77889   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
77890   jresult = (int)result;
77891   return jresult;
77892 }
77893
77894
77895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
77896   int jresult ;
77897   int result;
77898
77899   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
77900   jresult = (int)result;
77901   return jresult;
77902 }
77903
77904
77905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
77906   int jresult ;
77907   int result;
77908
77909   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
77910   jresult = (int)result;
77911   return jresult;
77912 }
77913
77914
77915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
77916   void * jresult ;
77917   Dali::Toolkit::PageTurnView::Property *result = 0 ;
77918
77919   {
77920     try {
77921       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
77922     } catch (std::out_of_range& e) {
77923       {
77924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77925       };
77926     } catch (std::exception& e) {
77927       {
77928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77929       };
77930     } catch (...) {
77931       {
77932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77933       };
77934     }
77935   }
77936   jresult = (void *)result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
77942   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
77943
77944   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
77945   {
77946     try {
77947       delete arg1;
77948     } catch (std::out_of_range& e) {
77949       {
77950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77951       };
77952     } catch (std::exception& e) {
77953       {
77954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77955       };
77956     } catch (...) {
77957       {
77958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77959       };
77960     }
77961   }
77962 }
77963
77964
77965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
77966   void * jresult ;
77967   Dali::Toolkit::PageTurnView *result = 0 ;
77968
77969   {
77970     try {
77971       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
77972     } catch (std::out_of_range& e) {
77973       {
77974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77975       };
77976     } catch (std::exception& e) {
77977       {
77978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77979       };
77980     } catch (...) {
77981       {
77982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77983       };
77984     }
77985   }
77986   jresult = (void *)result;
77987   return jresult;
77988 }
77989
77990
77991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
77992   void * jresult ;
77993   Dali::Toolkit::PageTurnView *arg1 = 0 ;
77994   Dali::Toolkit::PageTurnView *result = 0 ;
77995
77996   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
77997   if (!arg1) {
77998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
77999     return 0;
78000   }
78001   {
78002     try {
78003       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
78004     } catch (std::out_of_range& e) {
78005       {
78006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78007       };
78008     } catch (std::exception& e) {
78009       {
78010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78011       };
78012     } catch (...) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78015       };
78016     }
78017   }
78018   jresult = (void *)result;
78019   return jresult;
78020 }
78021
78022
78023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
78024   void * jresult ;
78025   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78026   Dali::Toolkit::PageTurnView *arg2 = 0 ;
78027   Dali::Toolkit::PageTurnView *result = 0 ;
78028
78029   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78030   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
78031   if (!arg2) {
78032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
78033     return 0;
78034   }
78035   {
78036     try {
78037       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
78038     } catch (std::out_of_range& e) {
78039       {
78040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78041       };
78042     } catch (std::exception& e) {
78043       {
78044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78045       };
78046     } catch (...) {
78047       {
78048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78049       };
78050     }
78051   }
78052   jresult = (void *)result;
78053   return jresult;
78054 }
78055
78056
78057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
78058   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78059
78060   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78061   {
78062     try {
78063       delete arg1;
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78071       };
78072     } catch (...) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78075       };
78076     }
78077   }
78078 }
78079
78080
78081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
78082   void * jresult ;
78083   Dali::BaseHandle arg1 ;
78084   Dali::BaseHandle *argp1 ;
78085   Dali::Toolkit::PageTurnView result;
78086
78087   argp1 = (Dali::BaseHandle *)jarg1;
78088   if (!argp1) {
78089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78090     return 0;
78091   }
78092   arg1 = *argp1;
78093   {
78094     try {
78095       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
78096     } catch (std::out_of_range& e) {
78097       {
78098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78099       };
78100     } catch (std::exception& e) {
78101       {
78102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78103       };
78104     } catch (...) {
78105       {
78106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78107       };
78108     }
78109   }
78110   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
78111   return jresult;
78112 }
78113
78114
78115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
78116   void * jresult ;
78117   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78118   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
78119
78120   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78121   {
78122     try {
78123       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
78124     } catch (std::out_of_range& e) {
78125       {
78126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78127       };
78128     } catch (std::exception& e) {
78129       {
78130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78131       };
78132     } catch (...) {
78133       {
78134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78135       };
78136     }
78137   }
78138   jresult = (void *)result;
78139   return jresult;
78140 }
78141
78142
78143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
78144   void * jresult ;
78145   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78146   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
78147
78148   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78149   {
78150     try {
78151       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
78152     } catch (std::out_of_range& e) {
78153       {
78154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78155       };
78156     } catch (std::exception& e) {
78157       {
78158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78159       };
78160     } catch (...) {
78161       {
78162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78163       };
78164     }
78165   }
78166   jresult = (void *)result;
78167   return jresult;
78168 }
78169
78170
78171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
78172   void * jresult ;
78173   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78174   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78175
78176   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78177   {
78178     try {
78179       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
78180     } catch (std::out_of_range& e) {
78181       {
78182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78183       };
78184     } catch (std::exception& e) {
78185       {
78186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78187       };
78188     } catch (...) {
78189       {
78190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78191       };
78192     }
78193   }
78194   jresult = (void *)result;
78195   return jresult;
78196 }
78197
78198
78199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
78200   void * jresult ;
78201   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
78202   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
78203
78204   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
78205   {
78206     try {
78207       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
78208     } catch (std::out_of_range& e) {
78209       {
78210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78211       };
78212     } catch (std::exception& e) {
78213       {
78214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (...) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78219       };
78220     }
78221   }
78222   jresult = (void *)result;
78223   return jresult;
78224 }
78225
78226
78227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
78228   void * jresult ;
78229   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78230
78231   {
78232     try {
78233       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
78234     } catch (std::out_of_range& e) {
78235       {
78236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78237       };
78238     } catch (std::exception& e) {
78239       {
78240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78241       };
78242     } catch (...) {
78243       {
78244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78245       };
78246     }
78247   }
78248   jresult = (void *)result;
78249   return jresult;
78250 }
78251
78252
78253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
78254   void * jresult ;
78255   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
78256   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78257
78258   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78259   if (!arg1) {
78260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78261     return 0;
78262   }
78263   {
78264     try {
78265       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
78266     } catch (std::out_of_range& e) {
78267       {
78268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78269       };
78270     } catch (std::exception& e) {
78271       {
78272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78273       };
78274     } catch (...) {
78275       {
78276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78277       };
78278     }
78279   }
78280   jresult = (void *)result;
78281   return jresult;
78282 }
78283
78284
78285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
78286   void * jresult ;
78287   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78288   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
78289   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
78290
78291   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78292   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
78293   if (!arg2) {
78294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
78295     return 0;
78296   }
78297   {
78298     try {
78299       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
78300     } catch (std::out_of_range& e) {
78301       {
78302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78303       };
78304     } catch (std::exception& e) {
78305       {
78306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78307       };
78308     } catch (...) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78311       };
78312     }
78313   }
78314   jresult = (void *)result;
78315   return jresult;
78316 }
78317
78318
78319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
78320   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
78321
78322   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
78323   {
78324     try {
78325       delete arg1;
78326     } catch (std::out_of_range& e) {
78327       {
78328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78329       };
78330     } catch (std::exception& e) {
78331       {
78332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78333       };
78334     } catch (...) {
78335       {
78336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78337       };
78338     }
78339   }
78340 }
78341
78342
78343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
78344   void * jresult ;
78345   Dali::Toolkit::PageFactory *arg1 = 0 ;
78346   Dali::Vector2 *arg2 = 0 ;
78347   Dali::Toolkit::PageTurnLandscapeView result;
78348
78349   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78350   if (!arg1) {
78351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78352     return 0;
78353   }
78354   arg2 = (Dali::Vector2 *)jarg2;
78355   if (!arg2) {
78356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78357     return 0;
78358   }
78359   {
78360     try {
78361       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
78362     } catch (std::out_of_range& e) {
78363       {
78364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78365       };
78366     } catch (std::exception& e) {
78367       {
78368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78369       };
78370     } catch (...) {
78371       {
78372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78373       };
78374     }
78375   }
78376   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78377   return jresult;
78378 }
78379
78380
78381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
78382   void * jresult ;
78383   Dali::BaseHandle arg1 ;
78384   Dali::BaseHandle *argp1 ;
78385   Dali::Toolkit::PageTurnLandscapeView result;
78386
78387   argp1 = (Dali::BaseHandle *)jarg1;
78388   if (!argp1) {
78389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78390     return 0;
78391   }
78392   arg1 = *argp1;
78393   {
78394     try {
78395       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
78396     } catch (std::out_of_range& e) {
78397       {
78398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78399       };
78400     } catch (std::exception& e) {
78401       {
78402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78403       };
78404     } catch (...) {
78405       {
78406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78407       };
78408     }
78409   }
78410   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
78411   return jresult;
78412 }
78413
78414
78415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
78416   void * jresult ;
78417   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78418
78419   {
78420     try {
78421       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
78422     } catch (std::out_of_range& e) {
78423       {
78424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78425       };
78426     } catch (std::exception& e) {
78427       {
78428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78429       };
78430     } catch (...) {
78431       {
78432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78433       };
78434     }
78435   }
78436   jresult = (void *)result;
78437   return jresult;
78438 }
78439
78440
78441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
78442   void * jresult ;
78443   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
78444   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78445
78446   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78447   if (!arg1) {
78448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78449     return 0;
78450   }
78451   {
78452     try {
78453       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
78454     } catch (std::out_of_range& e) {
78455       {
78456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78457       };
78458     } catch (std::exception& e) {
78459       {
78460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78461       };
78462     } catch (...) {
78463       {
78464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78465       };
78466     }
78467   }
78468   jresult = (void *)result;
78469   return jresult;
78470 }
78471
78472
78473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
78474   void * jresult ;
78475   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78476   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
78477   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
78478
78479   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78480   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
78481   if (!arg2) {
78482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
78483     return 0;
78484   }
78485   {
78486     try {
78487       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
78488     } catch (std::out_of_range& e) {
78489       {
78490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78491       };
78492     } catch (std::exception& e) {
78493       {
78494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78495       };
78496     } catch (...) {
78497       {
78498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78499       };
78500     }
78501   }
78502   jresult = (void *)result;
78503   return jresult;
78504 }
78505
78506
78507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
78508   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
78509
78510   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
78511   {
78512     try {
78513       delete arg1;
78514     } catch (std::out_of_range& e) {
78515       {
78516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78517       };
78518     } catch (std::exception& e) {
78519       {
78520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78521       };
78522     } catch (...) {
78523       {
78524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78525       };
78526     }
78527   }
78528 }
78529
78530
78531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
78532   void * jresult ;
78533   Dali::Toolkit::PageFactory *arg1 = 0 ;
78534   Dali::Vector2 *arg2 = 0 ;
78535   Dali::Toolkit::PageTurnPortraitView result;
78536
78537   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
78538   if (!arg1) {
78539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
78540     return 0;
78541   }
78542   arg2 = (Dali::Vector2 *)jarg2;
78543   if (!arg2) {
78544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78545     return 0;
78546   }
78547   {
78548     try {
78549       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
78550     } catch (std::out_of_range& e) {
78551       {
78552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78553       };
78554     } catch (std::exception& e) {
78555       {
78556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78557       };
78558     } catch (...) {
78559       {
78560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78561       };
78562     }
78563   }
78564   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78565   return jresult;
78566 }
78567
78568
78569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
78570   void * jresult ;
78571   Dali::BaseHandle arg1 ;
78572   Dali::BaseHandle *argp1 ;
78573   Dali::Toolkit::PageTurnPortraitView result;
78574
78575   argp1 = (Dali::BaseHandle *)jarg1;
78576   if (!argp1) {
78577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78578     return 0;
78579   }
78580   arg1 = *argp1;
78581   {
78582     try {
78583       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
78584     } catch (std::out_of_range& e) {
78585       {
78586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78587       };
78588     } catch (std::exception& e) {
78589       {
78590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78591       };
78592     } catch (...) {
78593       {
78594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78595       };
78596     }
78597   }
78598   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
78599   return jresult;
78600 }
78601
78602
78603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
78604   int jresult ;
78605   int result;
78606
78607   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
78608   jresult = (int)result;
78609   return jresult;
78610 }
78611
78612
78613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
78614   int jresult ;
78615   int result;
78616
78617   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
78618   jresult = (int)result;
78619   return jresult;
78620 }
78621
78622
78623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
78624   int jresult ;
78625   int result;
78626
78627   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
78628   jresult = (int)result;
78629   return jresult;
78630 }
78631
78632
78633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
78634   void * jresult ;
78635   Dali::Toolkit::ToggleButton::Property *result = 0 ;
78636
78637   {
78638     try {
78639       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
78640     } catch (std::out_of_range& e) {
78641       {
78642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78643       };
78644     } catch (std::exception& e) {
78645       {
78646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78647       };
78648     } catch (...) {
78649       {
78650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78651       };
78652     }
78653   }
78654   jresult = (void *)result;
78655   return jresult;
78656 }
78657
78658
78659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
78660   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
78661
78662   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
78663   {
78664     try {
78665       delete arg1;
78666     } catch (std::out_of_range& e) {
78667       {
78668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78669       };
78670     } catch (std::exception& e) {
78671       {
78672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78673       };
78674     } catch (...) {
78675       {
78676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78677       };
78678     }
78679   }
78680 }
78681
78682
78683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
78684   void * jresult ;
78685   Dali::Toolkit::ToggleButton *result = 0 ;
78686
78687   {
78688     try {
78689       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
78690     } catch (std::out_of_range& e) {
78691       {
78692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (std::exception& e) {
78695       {
78696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78697       };
78698     } catch (...) {
78699       {
78700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78701       };
78702     }
78703   }
78704   jresult = (void *)result;
78705   return jresult;
78706 }
78707
78708
78709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
78710   void * jresult ;
78711   Dali::Toolkit::ToggleButton *arg1 = 0 ;
78712   Dali::Toolkit::ToggleButton *result = 0 ;
78713
78714   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78715   if (!arg1) {
78716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78717     return 0;
78718   }
78719   {
78720     try {
78721       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
78722     } catch (std::out_of_range& e) {
78723       {
78724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78725       };
78726     } catch (std::exception& e) {
78727       {
78728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (...) {
78731       {
78732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78733       };
78734     }
78735   }
78736   jresult = (void *)result;
78737   return jresult;
78738 }
78739
78740
78741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
78742   void * jresult ;
78743   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78744   Dali::Toolkit::ToggleButton *arg2 = 0 ;
78745   Dali::Toolkit::ToggleButton *result = 0 ;
78746
78747   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78748   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
78749   if (!arg2) {
78750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
78751     return 0;
78752   }
78753   {
78754     try {
78755       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
78756     } catch (std::out_of_range& e) {
78757       {
78758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (std::exception& e) {
78761       {
78762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (...) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78767       };
78768     }
78769   }
78770   jresult = (void *)result;
78771   return jresult;
78772 }
78773
78774
78775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
78776   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
78777
78778   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
78779   {
78780     try {
78781       delete arg1;
78782     } catch (std::out_of_range& e) {
78783       {
78784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78785       };
78786     } catch (std::exception& e) {
78787       {
78788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78789       };
78790     } catch (...) {
78791       {
78792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78793       };
78794     }
78795   }
78796 }
78797
78798
78799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
78800   void * jresult ;
78801   Dali::Toolkit::ToggleButton result;
78802
78803   {
78804     try {
78805       result = Dali::Toolkit::ToggleButton::New();
78806     } catch (std::out_of_range& e) {
78807       {
78808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78809       };
78810     } catch (std::exception& e) {
78811       {
78812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78813       };
78814     } catch (...) {
78815       {
78816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78817       };
78818     }
78819   }
78820   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78821   return jresult;
78822 }
78823
78824
78825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
78826   void * jresult ;
78827   Dali::BaseHandle arg1 ;
78828   Dali::BaseHandle *argp1 ;
78829   Dali::Toolkit::ToggleButton result;
78830
78831   argp1 = (Dali::BaseHandle *)jarg1;
78832   if (!argp1) {
78833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78834     return 0;
78835   }
78836   arg1 = *argp1;
78837   {
78838     try {
78839       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
78840     } catch (std::out_of_range& e) {
78841       {
78842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78843       };
78844     } catch (std::exception& e) {
78845       {
78846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78847       };
78848     } catch (...) {
78849       {
78850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78851       };
78852     }
78853   }
78854   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
78855   return jresult;
78856 }
78857
78858
78859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
78860   void * jresult ;
78861   Dali::Toolkit::Visual::Base *result = 0 ;
78862
78863   {
78864     try {
78865       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
78866     } catch (std::out_of_range& e) {
78867       {
78868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78869       };
78870     } catch (std::exception& e) {
78871       {
78872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78873       };
78874     } catch (...) {
78875       {
78876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78877       };
78878     }
78879   }
78880   jresult = (void *)result;
78881   return jresult;
78882 }
78883
78884
78885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
78886   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78887
78888   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78889   {
78890     try {
78891       delete arg1;
78892     } catch (std::out_of_range& e) {
78893       {
78894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78895       };
78896     } catch (std::exception& e) {
78897       {
78898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78899       };
78900     } catch (...) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78903       };
78904     }
78905   }
78906 }
78907
78908
78909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
78910   void * jresult ;
78911   Dali::Toolkit::Visual::Base *arg1 = 0 ;
78912   Dali::Toolkit::Visual::Base *result = 0 ;
78913
78914   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78915   if (!arg1) {
78916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78917     return 0;
78918   }
78919   {
78920     try {
78921       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
78922     } catch (std::out_of_range& e) {
78923       {
78924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78925       };
78926     } catch (std::exception& e) {
78927       {
78928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78929       };
78930     } catch (...) {
78931       {
78932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78933       };
78934     }
78935   }
78936   jresult = (void *)result;
78937   return jresult;
78938 }
78939
78940
78941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
78942   void * jresult ;
78943   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78944   Dali::Toolkit::Visual::Base *arg2 = 0 ;
78945   Dali::Toolkit::Visual::Base *result = 0 ;
78946
78947   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78948   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
78949   if (!arg2) {
78950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
78951     return 0;
78952   }
78953   {
78954     try {
78955       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
78956     } catch (std::out_of_range& e) {
78957       {
78958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78959       };
78960     } catch (std::exception& e) {
78961       {
78962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78963       };
78964     } catch (...) {
78965       {
78966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78967       };
78968     }
78969   }
78970   jresult = (void *)result;
78971   return jresult;
78972 }
78973
78974
78975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
78976   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
78977   std::string *arg2 = 0 ;
78978
78979   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
78980   if (!jarg2) {
78981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78982     return ;
78983   }
78984   std::string arg2_str(jarg2);
78985   arg2 = &arg2_str;
78986   {
78987     try {
78988       (arg1)->SetName((std::string const &)*arg2);
78989     } catch (std::out_of_range& e) {
78990       {
78991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78992       };
78993     } catch (std::exception& e) {
78994       {
78995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78996       };
78997     } catch (...) {
78998       {
78999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79000       };
79001     }
79002   }
79003
79004   //argout typemap for const std::string&
79005
79006 }
79007
79008
79009 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
79010   char * jresult ;
79011   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79012   std::string *result = 0 ;
79013
79014   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79015   {
79016     try {
79017       result = (std::string *) &(arg1)->GetName();
79018     } catch (std::out_of_range& e) {
79019       {
79020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79021       };
79022     } catch (std::exception& e) {
79023       {
79024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79025       };
79026     } catch (...) {
79027       {
79028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79029       };
79030     }
79031   }
79032   jresult = SWIG_csharp_string_callback(result->c_str());
79033   return jresult;
79034 }
79035
79036
79037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
79038   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79039   Dali::Property::Map *arg2 = 0 ;
79040   Dali::Size arg3 ;
79041   Dali::Size *argp3 ;
79042
79043   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79044   arg2 = (Dali::Property::Map *)jarg2;
79045   if (!arg2) {
79046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79047     return ;
79048   }
79049   argp3 = (Dali::Size *)jarg3;
79050   if (!argp3) {
79051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
79052     return ;
79053   }
79054   arg3 = *argp3;
79055   {
79056     try {
79057       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
79058     } catch (std::out_of_range& e) {
79059       {
79060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79061       };
79062     } catch (std::exception& e) {
79063       {
79064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79065       };
79066     } catch (...) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79069       };
79070     }
79071   }
79072 }
79073
79074
79075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
79076   float jresult ;
79077   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79078   float arg2 ;
79079   float result;
79080
79081   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79082   arg2 = (float)jarg2;
79083   {
79084     try {
79085       result = (float)(arg1)->GetHeightForWidth(arg2);
79086     } catch (std::out_of_range& e) {
79087       {
79088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79089       };
79090     } catch (std::exception& e) {
79091       {
79092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (...) {
79095       {
79096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79097       };
79098     }
79099   }
79100   jresult = result;
79101   return jresult;
79102 }
79103
79104
79105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
79106   float jresult ;
79107   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79108   float arg2 ;
79109   float result;
79110
79111   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79112   arg2 = (float)jarg2;
79113   {
79114     try {
79115       result = (float)(arg1)->GetWidthForHeight(arg2);
79116     } catch (std::out_of_range& e) {
79117       {
79118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79119       };
79120     } catch (std::exception& e) {
79121       {
79122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79123       };
79124     } catch (...) {
79125       {
79126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79127       };
79128     }
79129   }
79130   jresult = result;
79131   return jresult;
79132 }
79133
79134
79135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
79136   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79137   Dali::Vector2 *arg2 = 0 ;
79138
79139   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79140   arg2 = (Dali::Vector2 *)jarg2;
79141   if (!arg2) {
79142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
79143     return ;
79144   }
79145   {
79146     try {
79147       (arg1)->GetNaturalSize(*arg2);
79148     } catch (std::out_of_range& e) {
79149       {
79150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79151       };
79152     } catch (std::exception& e) {
79153       {
79154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79155       };
79156     } catch (...) {
79157       {
79158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79159       };
79160     }
79161   }
79162 }
79163
79164
79165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
79166   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79167   float arg2 ;
79168
79169   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79170   arg2 = (int)jarg2;
79171   {
79172     try {
79173       (arg1)->SetDepthIndex(arg2);
79174     } catch (std::out_of_range& e) {
79175       {
79176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79177       };
79178     } catch (std::exception& e) {
79179       {
79180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79181       };
79182     } catch (...) {
79183       {
79184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79185       };
79186     }
79187   }
79188 }
79189
79190
79191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
79192   int jresult ;
79193   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79194   int result;
79195
79196   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79197   {
79198     try {
79199       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (...) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79211       };
79212     }
79213   }
79214   jresult = result;
79215   return jresult;
79216 }
79217
79218
79219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
79220   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
79221   Dali::Property::Map *arg2 = 0 ;
79222
79223   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
79224   arg2 = (Dali::Property::Map *)jarg2;
79225   if (!arg2) {
79226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
79227     return ;
79228   }
79229   {
79230     try {
79231       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
79232     } catch (std::out_of_range& e) {
79233       {
79234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79235       };
79236     } catch (std::exception& e) {
79237       {
79238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79239       };
79240     } catch (...) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79243       };
79244     }
79245   }
79246 }
79247
79248
79249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
79250   void * jresult ;
79251   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
79252   Dali::Toolkit::Visual::Base *result = 0 ;
79253
79254   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
79255   {
79256     try {
79257       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
79258     } catch (std::out_of_range& e) {
79259       {
79260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79261       };
79262     } catch (std::exception& e) {
79263       {
79264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79265       };
79266     } catch (...) {
79267       {
79268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79269       };
79270     }
79271   }
79272   jresult = (void *)result;
79273   return jresult;
79274 }
79275
79276
79277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
79278   void * jresult ;
79279   Dali::Toolkit::VisualFactory result;
79280
79281   {
79282     try {
79283       result = Dali::Toolkit::VisualFactory::Get();
79284     } catch (std::out_of_range& e) {
79285       {
79286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79287       };
79288     } catch (std::exception& e) {
79289       {
79290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79291       };
79292     } catch (...) {
79293       {
79294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79295       };
79296     }
79297   }
79298   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
79299   return jresult;
79300 }
79301
79302
79303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
79304   void * jresult ;
79305   Dali::Toolkit::VisualFactory *result = 0 ;
79306
79307   {
79308     try {
79309       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
79310     } catch (std::out_of_range& e) {
79311       {
79312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79313       };
79314     } catch (std::exception& e) {
79315       {
79316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79317       };
79318     } catch (...) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79321       };
79322     }
79323   }
79324   jresult = (void *)result;
79325   return jresult;
79326 }
79327
79328
79329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
79330   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79331
79332   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79333   {
79334     try {
79335       delete arg1;
79336     } catch (std::out_of_range& e) {
79337       {
79338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79339       };
79340     } catch (std::exception& e) {
79341       {
79342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79343       };
79344     } catch (...) {
79345       {
79346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79347       };
79348     }
79349   }
79350 }
79351
79352
79353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
79354   void * jresult ;
79355   Dali::Toolkit::VisualFactory *arg1 = 0 ;
79356   Dali::Toolkit::VisualFactory *result = 0 ;
79357
79358   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79359   if (!arg1) {
79360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79361     return 0;
79362   }
79363   {
79364     try {
79365       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
79366     } catch (std::out_of_range& e) {
79367       {
79368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79369       };
79370     } catch (std::exception& e) {
79371       {
79372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79373       };
79374     } catch (...) {
79375       {
79376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79377       };
79378     }
79379   }
79380   jresult = (void *)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
79386   void * jresult ;
79387   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79388   Dali::Toolkit::VisualFactory *arg2 = 0 ;
79389   Dali::Toolkit::VisualFactory *result = 0 ;
79390
79391   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79392   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
79393   if (!arg2) {
79394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
79395     return 0;
79396   }
79397   {
79398     try {
79399       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
79400     } catch (std::out_of_range& e) {
79401       {
79402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79403       };
79404     } catch (std::exception& e) {
79405       {
79406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79407       };
79408     } catch (...) {
79409       {
79410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79411       };
79412     }
79413   }
79414   jresult = (void *)result;
79415   return jresult;
79416 }
79417
79418
79419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
79420   void * jresult ;
79421   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79422   Dali::Property::Map *arg2 = 0 ;
79423   Dali::Toolkit::Visual::Base result;
79424
79425   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79426   arg2 = (Dali::Property::Map *)jarg2;
79427   if (!arg2) {
79428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
79429     return 0;
79430   }
79431   {
79432     try {
79433       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
79434     } catch (std::out_of_range& e) {
79435       {
79436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (std::exception& e) {
79439       {
79440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79445       };
79446     }
79447   }
79448   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79449   return jresult;
79450 }
79451
79452
79453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
79454   void * jresult ;
79455   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79456   Dali::Image *arg2 = 0 ;
79457   Dali::Toolkit::Visual::Base result;
79458
79459   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79460   arg2 = (Dali::Image *)jarg2;
79461   if (!arg2) {
79462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
79463     return 0;
79464   }
79465   {
79466     try {
79467       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
79468     } catch (std::out_of_range& e) {
79469       {
79470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79471       };
79472     } catch (std::exception& e) {
79473       {
79474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79475       };
79476     } catch (...) {
79477       {
79478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79479       };
79480     }
79481   }
79482   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79483   return jresult;
79484 }
79485
79486
79487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
79488   void * jresult ;
79489   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
79490   std::string *arg2 = 0 ;
79491   Dali::ImageDimensions arg3 ;
79492   Dali::ImageDimensions *argp3 ;
79493   Dali::Toolkit::Visual::Base result;
79494
79495   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
79496   if (!jarg2) {
79497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79498     return 0;
79499   }
79500   std::string arg2_str(jarg2);
79501   arg2 = &arg2_str;
79502   argp3 = (Dali::ImageDimensions *)jarg3;
79503   if (!argp3) {
79504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79505     return 0;
79506   }
79507   arg3 = *argp3;
79508   {
79509     try {
79510       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
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::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
79526
79527   //argout typemap for const std::string&
79528
79529   return jresult;
79530 }
79531
79532
79533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
79534   void * jresult ;
79535   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79536
79537   {
79538     try {
79539       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
79540     } catch (std::out_of_range& e) {
79541       {
79542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79543       };
79544     } catch (std::exception& e) {
79545       {
79546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79547       };
79548     } catch (...) {
79549       {
79550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79551       };
79552     }
79553   }
79554   jresult = (void *)result;
79555   return jresult;
79556 }
79557
79558
79559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
79560   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79561
79562   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79563   {
79564     try {
79565       delete arg1;
79566     } catch (std::out_of_range& e) {
79567       {
79568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79569       };
79570     } catch (std::exception& e) {
79571       {
79572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79573       };
79574     } catch (...) {
79575       {
79576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79577       };
79578     }
79579   }
79580 }
79581
79582
79583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
79584   void * jresult ;
79585   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
79586   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79587
79588   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79589   if (!arg1) {
79590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79591     return 0;
79592   }
79593   {
79594     try {
79595       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
79596     } catch (std::out_of_range& e) {
79597       {
79598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79599       };
79600     } catch (std::exception& e) {
79601       {
79602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79603       };
79604     } catch (...) {
79605       {
79606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79607       };
79608     }
79609   }
79610   jresult = (void *)result;
79611   return jresult;
79612 }
79613
79614
79615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
79616   void * jresult ;
79617   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79618   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
79619   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79620
79621   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79622   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
79623   if (!arg2) {
79624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
79625     return 0;
79626   }
79627   {
79628     try {
79629       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
79630     } catch (std::out_of_range& e) {
79631       {
79632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79633       };
79634     } catch (std::exception& e) {
79635       {
79636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79637       };
79638     } catch (...) {
79639       {
79640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79641       };
79642     }
79643   }
79644   jresult = (void *)result;
79645   return jresult;
79646 }
79647
79648
79649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
79650   void * jresult ;
79651   Dali::Toolkit::AsyncImageLoader result;
79652
79653   {
79654     try {
79655       result = Dali::Toolkit::AsyncImageLoader::New();
79656     } catch (std::out_of_range& e) {
79657       {
79658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79659       };
79660     } catch (std::exception& e) {
79661       {
79662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79663       };
79664     } catch (...) {
79665       {
79666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79667       };
79668     }
79669   }
79670   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79671   return jresult;
79672 }
79673
79674
79675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
79676   void * jresult ;
79677   Dali::BaseHandle arg1 ;
79678   Dali::BaseHandle *argp1 ;
79679   Dali::Toolkit::AsyncImageLoader result;
79680
79681   argp1 = (Dali::BaseHandle *)jarg1;
79682   if (!argp1) {
79683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79684     return 0;
79685   }
79686   arg1 = *argp1;
79687   {
79688     try {
79689       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
79690     } catch (std::out_of_range& e) {
79691       {
79692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79693       };
79694     } catch (std::exception& e) {
79695       {
79696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (...) {
79699       {
79700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79701       };
79702     }
79703   }
79704   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
79705   return jresult;
79706 }
79707
79708
79709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
79710   unsigned int jresult ;
79711   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79712   std::string *arg2 = 0 ;
79713   uint32_t result;
79714
79715   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79716   if (!jarg2) {
79717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79718     return 0;
79719   }
79720   std::string arg2_str(jarg2);
79721   arg2 = &arg2_str;
79722   {
79723     try {
79724       result = (arg1)->Load((std::string const &)*arg2);
79725     } catch (std::out_of_range& e) {
79726       {
79727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79728       };
79729     } catch (std::exception& e) {
79730       {
79731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (...) {
79734       {
79735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79736       };
79737     }
79738   }
79739   jresult = result;
79740
79741   //argout typemap for const std::string&
79742
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
79748   unsigned int jresult ;
79749   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79750   std::string *arg2 = 0 ;
79751   Dali::ImageDimensions arg3 ;
79752   Dali::ImageDimensions *argp3 ;
79753   uint32_t result;
79754
79755   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79756   if (!jarg2) {
79757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79758     return 0;
79759   }
79760   std::string arg2_str(jarg2);
79761   arg2 = &arg2_str;
79762   argp3 = (Dali::ImageDimensions *)jarg3;
79763   if (!argp3) {
79764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79765     return 0;
79766   }
79767   arg3 = *argp3;
79768   {
79769     try {
79770       result = (arg1)->Load((std::string const &)*arg2,arg3);
79771     } catch (std::out_of_range& e) {
79772       {
79773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79774       };
79775     } catch (std::exception& e) {
79776       {
79777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79778       };
79779     } catch (...) {
79780       {
79781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79782       };
79783     }
79784   }
79785   jresult = result;
79786
79787   //argout typemap for const std::string&
79788
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
79794   unsigned int jresult ;
79795   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79796   std::string *arg2 = 0 ;
79797   Dali::ImageDimensions arg3 ;
79798   Dali::FittingMode::Type arg4 ;
79799   Dali::SamplingMode::Type arg5 ;
79800   bool arg6 ;
79801   Dali::ImageDimensions *argp3 ;
79802   uint32_t result;
79803
79804   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79805   if (!jarg2) {
79806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79807     return 0;
79808   }
79809   std::string arg2_str(jarg2);
79810   arg2 = &arg2_str;
79811   argp3 = (Dali::ImageDimensions *)jarg3;
79812   if (!argp3) {
79813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
79814     return 0;
79815   }
79816   arg3 = *argp3;
79817   arg4 = (Dali::FittingMode::Type)jarg4;
79818   arg5 = (Dali::SamplingMode::Type)jarg5;
79819   arg6 = jarg6 ? true : false;
79820   {
79821     try {
79822       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
79823     } catch (std::out_of_range& e) {
79824       {
79825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79826       };
79827     } catch (std::exception& e) {
79828       {
79829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79830       };
79831     } catch (...) {
79832       {
79833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79834       };
79835     }
79836   }
79837   jresult = result;
79838
79839   //argout typemap for const std::string&
79840
79841   return jresult;
79842 }
79843
79844
79845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
79846   unsigned int jresult ;
79847   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79848   uint32_t arg2 ;
79849   bool result;
79850
79851   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79852   arg2 = (uint32_t)jarg2;
79853   {
79854     try {
79855       result = (bool)(arg1)->Cancel(arg2);
79856     } catch (std::out_of_range& e) {
79857       {
79858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79859       };
79860     } catch (std::exception& e) {
79861       {
79862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79863       };
79864     } catch (...) {
79865       {
79866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79867       };
79868     }
79869   }
79870   jresult = result;
79871   return jresult;
79872 }
79873
79874
79875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
79876   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79877
79878   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79879   {
79880     try {
79881       (arg1)->CancelAll();
79882     } catch (std::out_of_range& e) {
79883       {
79884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79885       };
79886     } catch (std::exception& e) {
79887       {
79888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79889       };
79890     } catch (...) {
79891       {
79892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79893       };
79894     }
79895   }
79896 }
79897
79898
79899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
79900   void * jresult ;
79901   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
79902   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
79903
79904   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
79905   {
79906     try {
79907       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
79908     } catch (std::out_of_range& e) {
79909       {
79910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79911       };
79912     } catch (std::exception& e) {
79913       {
79914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79915       };
79916     } catch (...) {
79917       {
79918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79919       };
79920     }
79921   }
79922   jresult = (void *)result;
79923   return jresult;
79924 }
79925
79926
79927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
79928   void * jresult ;
79929   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
79930   Dali::Toolkit::AsyncImageLoader *result = 0 ;
79931
79932   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
79933   {
79934     try {
79935       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
79936     } catch (std::out_of_range& e) {
79937       {
79938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79939       };
79940     } catch (std::exception& e) {
79941       {
79942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79943       };
79944     } catch (...) {
79945       {
79946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79947       };
79948     }
79949   }
79950   jresult = (void *)result;
79951   return jresult;
79952 }
79953
79954
79955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
79956   void * jresult ;
79957   std::string *arg1 = 0 ;
79958   Dali::PixelData result;
79959
79960   if (!jarg1) {
79961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79962     return 0;
79963   }
79964   std::string arg1_str(jarg1);
79965   arg1 = &arg1_str;
79966   {
79967     try {
79968       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
79969     } catch (std::out_of_range& e) {
79970       {
79971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79972       };
79973     } catch (std::exception& e) {
79974       {
79975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79976       };
79977     } catch (...) {
79978       {
79979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79980       };
79981     }
79982   }
79983   jresult = new Dali::PixelData((const Dali::PixelData &)result);
79984
79985   //argout typemap for const std::string&
79986
79987   return jresult;
79988 }
79989
79990
79991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
79992   void * jresult ;
79993   std::string *arg1 = 0 ;
79994   Dali::ImageDimensions arg2 ;
79995   Dali::ImageDimensions *argp2 ;
79996   Dali::PixelData result;
79997
79998   if (!jarg1) {
79999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80000     return 0;
80001   }
80002   std::string arg1_str(jarg1);
80003   arg1 = &arg1_str;
80004   argp2 = (Dali::ImageDimensions *)jarg2;
80005   if (!argp2) {
80006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
80007     return 0;
80008   }
80009   arg2 = *argp2;
80010   {
80011     try {
80012       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
80013     } catch (std::out_of_range& e) {
80014       {
80015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80016       };
80017     } catch (std::exception& e) {
80018       {
80019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80020       };
80021     } catch (...) {
80022       {
80023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80024       };
80025     }
80026   }
80027   jresult = new Dali::PixelData((const Dali::PixelData &)result);
80028
80029   //argout typemap for const std::string&
80030
80031   return jresult;
80032 }
80033
80034
80035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
80036   void * jresult ;
80037   std::string *arg1 = 0 ;
80038   Dali::ImageDimensions arg2 ;
80039   Dali::FittingMode::Type arg3 ;
80040   Dali::SamplingMode::Type arg4 ;
80041   bool arg5 ;
80042   Dali::ImageDimensions *argp2 ;
80043   Dali::PixelData result;
80044
80045   if (!jarg1) {
80046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80047     return 0;
80048   }
80049   std::string arg1_str(jarg1);
80050   arg1 = &arg1_str;
80051   argp2 = (Dali::ImageDimensions *)jarg2;
80052   if (!argp2) {
80053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
80054     return 0;
80055   }
80056   arg2 = *argp2;
80057   arg3 = (Dali::FittingMode::Type)jarg3;
80058   arg4 = (Dali::SamplingMode::Type)jarg4;
80059   arg5 = jarg5 ? true : false;
80060   {
80061     try {
80062       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
80063     } catch (std::out_of_range& e) {
80064       {
80065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80066       };
80067     } catch (std::exception& e) {
80068       {
80069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80070       };
80071     } catch (...) {
80072       {
80073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80074       };
80075     }
80076   }
80077   jresult = new Dali::PixelData((const Dali::PixelData &)result);
80078
80079   //argout typemap for const std::string&
80080
80081   return jresult;
80082 }
80083
80084
80085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
80086   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
80087
80088   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
80089   {
80090     try {
80091       delete arg1;
80092     } catch (std::out_of_range& e) {
80093       {
80094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80095       };
80096     } catch (std::exception& e) {
80097       {
80098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80099       };
80100     } catch (...) {
80101       {
80102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80103       };
80104     }
80105   }
80106 }
80107
80108
80109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
80110   void * jresult ;
80111   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
80112   Dali::Actor arg2 ;
80113   Dali::Actor arg3 ;
80114   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
80115   Dali::Actor *argp2 ;
80116   Dali::Actor *argp3 ;
80117   Dali::Actor result;
80118
80119   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
80120   argp2 = (Dali::Actor *)jarg2;
80121   if (!argp2) {
80122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80123     return 0;
80124   }
80125   arg2 = *argp2;
80126   argp3 = (Dali::Actor *)jarg3;
80127   if (!argp3) {
80128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80129     return 0;
80130   }
80131   arg3 = *argp3;
80132   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
80133   {
80134     try {
80135       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
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 = new Dali::Actor((const Dali::Actor &)result);
80151   return jresult;
80152 }
80153
80154
80155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
80156   void * jresult ;
80157   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
80158
80159   {
80160     try {
80161       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
80162     } catch (std::out_of_range& e) {
80163       {
80164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80165       };
80166     } catch (std::exception& e) {
80167       {
80168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80169       };
80170     } catch (...) {
80171       {
80172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80173       };
80174     }
80175   }
80176   jresult = (void *)result;
80177   return jresult;
80178 }
80179
80180
80181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
80182   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
80183   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
80184   if (director) {
80185     director->swig_connect_director(callback0);
80186   }
80187 }
80188
80189
80190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
80191   KeyboardFocusManager arg1 ;
80192   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
80193   KeyboardFocusManager *argp1 ;
80194
80195   argp1 = (KeyboardFocusManager *)jarg1;
80196   if (!argp1) {
80197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
80198     return ;
80199   }
80200   arg1 = *argp1;
80201   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
80202   if (!arg2) {
80203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
80204     return ;
80205   }
80206   {
80207     try {
80208       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80220       };
80221     }
80222   }
80223 }
80224
80225
80226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
80227   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80228
80229   arg1 = (std::vector< unsigned int > *)jarg1;
80230   {
80231     try {
80232       (arg1)->clear();
80233     } catch (std::out_of_range& e) {
80234       {
80235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80236       };
80237     } catch (std::exception& e) {
80238       {
80239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80240       };
80241     } catch (...) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80244       };
80245     }
80246   }
80247 }
80248
80249
80250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
80251   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80252   unsigned int *arg2 = 0 ;
80253   unsigned int temp2 ;
80254
80255   arg1 = (std::vector< unsigned int > *)jarg1;
80256   temp2 = (unsigned int)jarg2;
80257   arg2 = &temp2;
80258   {
80259     try {
80260       (arg1)->push_back((unsigned int const &)*arg2);
80261     } catch (std::out_of_range& e) {
80262       {
80263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80264       };
80265     } catch (std::exception& e) {
80266       {
80267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80268       };
80269     } catch (...) {
80270       {
80271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80272       };
80273     }
80274   }
80275 }
80276
80277
80278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
80279   unsigned long jresult ;
80280   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80281   std::vector< unsigned int >::size_type result;
80282
80283   arg1 = (std::vector< unsigned int > *)jarg1;
80284   {
80285     try {
80286       result = ((std::vector< unsigned int > const *)arg1)->size();
80287     } catch (std::out_of_range& e) {
80288       {
80289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80290       };
80291     } catch (std::exception& e) {
80292       {
80293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80294       };
80295     } catch (...) {
80296       {
80297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80298       };
80299     }
80300   }
80301   jresult = (unsigned long)result;
80302   return jresult;
80303 }
80304
80305
80306 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
80307   unsigned long jresult ;
80308   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80309   std::vector< unsigned int >::size_type result;
80310
80311   arg1 = (std::vector< unsigned int > *)jarg1;
80312   {
80313     try {
80314       result = ((std::vector< unsigned int > const *)arg1)->capacity();
80315     } catch (std::out_of_range& e) {
80316       {
80317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80318       };
80319     } catch (std::exception& e) {
80320       {
80321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80322       };
80323     } catch (...) {
80324       {
80325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80326       };
80327     }
80328   }
80329   jresult = (unsigned long)result;
80330   return jresult;
80331 }
80332
80333
80334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
80335   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80336   std::vector< unsigned int >::size_type arg2 ;
80337
80338   arg1 = (std::vector< unsigned int > *)jarg1;
80339   arg2 = (std::vector< unsigned int >::size_type)jarg2;
80340   {
80341     try {
80342       (arg1)->reserve(arg2);
80343     } catch (std::out_of_range& e) {
80344       {
80345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80346       };
80347     } catch (std::exception& e) {
80348       {
80349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80350       };
80351     } catch (...) {
80352       {
80353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80354       };
80355     }
80356   }
80357 }
80358
80359
80360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
80361   void * jresult ;
80362   std::vector< unsigned int > *result = 0 ;
80363
80364   {
80365     try {
80366       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
80367     } catch (std::out_of_range& e) {
80368       {
80369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80370       };
80371     } catch (std::exception& e) {
80372       {
80373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80374       };
80375     } catch (...) {
80376       {
80377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80378       };
80379     }
80380   }
80381   jresult = (void *)result;
80382   return jresult;
80383 }
80384
80385
80386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
80387   void * jresult ;
80388   std::vector< unsigned int > *arg1 = 0 ;
80389   std::vector< unsigned int > *result = 0 ;
80390
80391   arg1 = (std::vector< unsigned int > *)jarg1;
80392   if (!arg1) {
80393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80394     return 0;
80395   }
80396   {
80397     try {
80398       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
80399     } catch (std::out_of_range& e) {
80400       {
80401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80402       };
80403     } catch (std::exception& e) {
80404       {
80405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80406       };
80407     } catch (...) {
80408       {
80409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80410       };
80411     }
80412   }
80413   jresult = (void *)result;
80414   return jresult;
80415 }
80416
80417
80418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
80419   void * jresult ;
80420   int arg1 ;
80421   std::vector< unsigned int > *result = 0 ;
80422
80423   arg1 = (int)jarg1;
80424   {
80425     try {
80426       try {
80427         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
80428       }
80429       catch(std::out_of_range &_e) {
80430         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80431         return 0;
80432       }
80433
80434     } catch (std::out_of_range& e) {
80435       {
80436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80437       };
80438     } catch (std::exception& e) {
80439       {
80440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (...) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80445       };
80446     }
80447   }
80448   jresult = (void *)result;
80449   return jresult;
80450 }
80451
80452
80453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
80454   unsigned int jresult ;
80455   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80456   int arg2 ;
80457   unsigned int result;
80458
80459   arg1 = (std::vector< unsigned int > *)jarg1;
80460   arg2 = (int)jarg2;
80461   {
80462     try {
80463       try {
80464         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
80465       }
80466       catch(std::out_of_range &_e) {
80467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80468         return 0;
80469       }
80470
80471     } catch (std::out_of_range& e) {
80472       {
80473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (std::exception& e) {
80476       {
80477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80478       };
80479     } catch (...) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80482       };
80483     }
80484   }
80485   jresult = result;
80486   return jresult;
80487 }
80488
80489
80490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
80491   unsigned int jresult ;
80492   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80493   int arg2 ;
80494   unsigned int *result = 0 ;
80495
80496   arg1 = (std::vector< unsigned int > *)jarg1;
80497   arg2 = (int)jarg2;
80498   {
80499     try {
80500       try {
80501         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
80502       }
80503       catch(std::out_of_range &_e) {
80504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80505         return 0;
80506       }
80507
80508     } catch (std::out_of_range& e) {
80509       {
80510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80511       };
80512     } catch (std::exception& e) {
80513       {
80514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (...) {
80517       {
80518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80519       };
80520     }
80521   }
80522   jresult = *result;
80523   return jresult;
80524 }
80525
80526
80527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
80528   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80529   int arg2 ;
80530   unsigned int *arg3 = 0 ;
80531   unsigned int temp3 ;
80532
80533   arg1 = (std::vector< unsigned int > *)jarg1;
80534   arg2 = (int)jarg2;
80535   temp3 = (unsigned int)jarg3;
80536   arg3 = &temp3;
80537   {
80538     try {
80539       try {
80540         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
80541       }
80542       catch(std::out_of_range &_e) {
80543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80544         return ;
80545       }
80546
80547     } catch (std::out_of_range& e) {
80548       {
80549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80550       };
80551     } catch (std::exception& e) {
80552       {
80553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80554       };
80555     } catch (...) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80558       };
80559     }
80560   }
80561 }
80562
80563
80564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
80565   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80566   std::vector< unsigned int > *arg2 = 0 ;
80567
80568   arg1 = (std::vector< unsigned int > *)jarg1;
80569   arg2 = (std::vector< unsigned int > *)jarg2;
80570   if (!arg2) {
80571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80572     return ;
80573   }
80574   {
80575     try {
80576       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
80577     } catch (std::out_of_range& e) {
80578       {
80579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80580       };
80581     } catch (std::exception& e) {
80582       {
80583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (...) {
80586       {
80587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80588       };
80589     }
80590   }
80591 }
80592
80593
80594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
80595   void * jresult ;
80596   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80597   int arg2 ;
80598   int arg3 ;
80599   std::vector< unsigned int > *result = 0 ;
80600
80601   arg1 = (std::vector< unsigned int > *)jarg1;
80602   arg2 = (int)jarg2;
80603   arg3 = (int)jarg3;
80604   {
80605     try {
80606       try {
80607         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
80608       }
80609       catch(std::out_of_range &_e) {
80610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80611         return 0;
80612       }
80613       catch(std::invalid_argument &_e) {
80614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80615         return 0;
80616       }
80617
80618     } catch (std::out_of_range& e) {
80619       {
80620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80621       };
80622     } catch (std::exception& e) {
80623       {
80624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80625       };
80626     } catch (...) {
80627       {
80628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80629       };
80630     }
80631   }
80632   jresult = (void *)result;
80633   return jresult;
80634 }
80635
80636
80637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
80638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80639   int arg2 ;
80640   unsigned int *arg3 = 0 ;
80641   unsigned int temp3 ;
80642
80643   arg1 = (std::vector< unsigned int > *)jarg1;
80644   arg2 = (int)jarg2;
80645   temp3 = (unsigned int)jarg3;
80646   arg3 = &temp3;
80647   {
80648     try {
80649       try {
80650         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
80651       }
80652       catch(std::out_of_range &_e) {
80653         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80654         return ;
80655       }
80656
80657     } catch (std::out_of_range& e) {
80658       {
80659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80660       };
80661     } catch (std::exception& e) {
80662       {
80663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80664       };
80665     } catch (...) {
80666       {
80667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80668       };
80669     }
80670   }
80671 }
80672
80673
80674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
80675   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80676   int arg2 ;
80677   std::vector< unsigned int > *arg3 = 0 ;
80678
80679   arg1 = (std::vector< unsigned int > *)jarg1;
80680   arg2 = (int)jarg2;
80681   arg3 = (std::vector< unsigned int > *)jarg3;
80682   if (!arg3) {
80683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80684     return ;
80685   }
80686   {
80687     try {
80688       try {
80689         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80690       }
80691       catch(std::out_of_range &_e) {
80692         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80693         return ;
80694       }
80695
80696     } catch (std::out_of_range& e) {
80697       {
80698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80699       };
80700     } catch (std::exception& e) {
80701       {
80702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80703       };
80704     } catch (...) {
80705       {
80706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80707       };
80708     }
80709   }
80710 }
80711
80712
80713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
80714   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80715   int arg2 ;
80716
80717   arg1 = (std::vector< unsigned int > *)jarg1;
80718   arg2 = (int)jarg2;
80719   {
80720     try {
80721       try {
80722         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
80723       }
80724       catch(std::out_of_range &_e) {
80725         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80726         return ;
80727       }
80728
80729     } catch (std::out_of_range& e) {
80730       {
80731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80732       };
80733     } catch (std::exception& e) {
80734       {
80735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80736       };
80737     } catch (...) {
80738       {
80739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80740       };
80741     }
80742   }
80743 }
80744
80745
80746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
80747   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80748   int arg2 ;
80749   int arg3 ;
80750
80751   arg1 = (std::vector< unsigned int > *)jarg1;
80752   arg2 = (int)jarg2;
80753   arg3 = (int)jarg3;
80754   {
80755     try {
80756       try {
80757         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
80758       }
80759       catch(std::out_of_range &_e) {
80760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80761         return ;
80762       }
80763       catch(std::invalid_argument &_e) {
80764         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80765         return ;
80766       }
80767
80768     } catch (std::out_of_range& e) {
80769       {
80770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80771       };
80772     } catch (std::exception& e) {
80773       {
80774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80775       };
80776     } catch (...) {
80777       {
80778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80779       };
80780     }
80781   }
80782 }
80783
80784
80785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
80786   void * jresult ;
80787   unsigned int *arg1 = 0 ;
80788   int arg2 ;
80789   unsigned int temp1 ;
80790   std::vector< unsigned int > *result = 0 ;
80791
80792   temp1 = (unsigned int)jarg1;
80793   arg1 = &temp1;
80794   arg2 = (int)jarg2;
80795   {
80796     try {
80797       try {
80798         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
80799       }
80800       catch(std::out_of_range &_e) {
80801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80802         return 0;
80803       }
80804
80805     } catch (std::out_of_range& e) {
80806       {
80807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80808       };
80809     } catch (std::exception& e) {
80810       {
80811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80812       };
80813     } catch (...) {
80814       {
80815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80816       };
80817     }
80818   }
80819   jresult = (void *)result;
80820   return jresult;
80821 }
80822
80823
80824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
80825   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80826
80827   arg1 = (std::vector< unsigned int > *)jarg1;
80828   {
80829     try {
80830       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
80831     } catch (std::out_of_range& e) {
80832       {
80833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80834       };
80835     } catch (std::exception& e) {
80836       {
80837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80838       };
80839     } catch (...) {
80840       {
80841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80842       };
80843     }
80844   }
80845 }
80846
80847
80848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
80849   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80850   int arg2 ;
80851   int arg3 ;
80852
80853   arg1 = (std::vector< unsigned int > *)jarg1;
80854   arg2 = (int)jarg2;
80855   arg3 = (int)jarg3;
80856   {
80857     try {
80858       try {
80859         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
80860       }
80861       catch(std::out_of_range &_e) {
80862         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80863         return ;
80864       }
80865       catch(std::invalid_argument &_e) {
80866         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
80867         return ;
80868       }
80869
80870     } catch (std::out_of_range& e) {
80871       {
80872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (std::exception& e) {
80875       {
80876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80877       };
80878     } catch (...) {
80879       {
80880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80881       };
80882     }
80883   }
80884 }
80885
80886
80887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
80888   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80889   int arg2 ;
80890   std::vector< unsigned int > *arg3 = 0 ;
80891
80892   arg1 = (std::vector< unsigned int > *)jarg1;
80893   arg2 = (int)jarg2;
80894   arg3 = (std::vector< unsigned int > *)jarg3;
80895   if (!arg3) {
80896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
80897     return ;
80898   }
80899   {
80900     try {
80901       try {
80902         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
80903       }
80904       catch(std::out_of_range &_e) {
80905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
80906         return ;
80907       }
80908
80909     } catch (std::out_of_range& e) {
80910       {
80911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80912       };
80913     } catch (std::exception& e) {
80914       {
80915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80916       };
80917     } catch (...) {
80918       {
80919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80920       };
80921     }
80922   }
80923 }
80924
80925
80926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
80927   unsigned int jresult ;
80928   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80929   unsigned int *arg2 = 0 ;
80930   unsigned int temp2 ;
80931   bool result;
80932
80933   arg1 = (std::vector< unsigned int > *)jarg1;
80934   temp2 = (unsigned int)jarg2;
80935   arg2 = &temp2;
80936   {
80937     try {
80938       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
80939     } catch (std::out_of_range& e) {
80940       {
80941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (std::exception& e) {
80944       {
80945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (...) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80950       };
80951     }
80952   }
80953   jresult = result;
80954   return jresult;
80955 }
80956
80957
80958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
80959   int jresult ;
80960   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80961   unsigned int *arg2 = 0 ;
80962   unsigned int temp2 ;
80963   int result;
80964
80965   arg1 = (std::vector< unsigned int > *)jarg1;
80966   temp2 = (unsigned int)jarg2;
80967   arg2 = &temp2;
80968   {
80969     try {
80970       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
80971     } catch (std::out_of_range& e) {
80972       {
80973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (std::exception& e) {
80976       {
80977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (...) {
80980       {
80981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80982       };
80983     }
80984   }
80985   jresult = result;
80986   return jresult;
80987 }
80988
80989
80990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
80991   int jresult ;
80992   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
80993   unsigned int *arg2 = 0 ;
80994   unsigned int temp2 ;
80995   int result;
80996
80997   arg1 = (std::vector< unsigned int > *)jarg1;
80998   temp2 = (unsigned int)jarg2;
80999   arg2 = &temp2;
81000   {
81001     try {
81002       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
81003     } catch (std::out_of_range& e) {
81004       {
81005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81006       };
81007     } catch (std::exception& e) {
81008       {
81009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81010       };
81011     } catch (...) {
81012       {
81013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81014       };
81015     }
81016   }
81017   jresult = result;
81018   return jresult;
81019 }
81020
81021
81022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
81023   unsigned int jresult ;
81024   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81025   unsigned int *arg2 = 0 ;
81026   unsigned int temp2 ;
81027   bool result;
81028
81029   arg1 = (std::vector< unsigned int > *)jarg1;
81030   temp2 = (unsigned int)jarg2;
81031   arg2 = &temp2;
81032   {
81033     try {
81034       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
81035     } catch (std::out_of_range& e) {
81036       {
81037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81038       };
81039     } catch (std::exception& e) {
81040       {
81041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81042       };
81043     } catch (...) {
81044       {
81045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81046       };
81047     }
81048   }
81049   jresult = result;
81050   return jresult;
81051 }
81052
81053
81054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
81055   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
81056
81057   arg1 = (std::vector< unsigned int > *)jarg1;
81058   {
81059     try {
81060       delete arg1;
81061     } catch (std::out_of_range& e) {
81062       {
81063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81064       };
81065     } catch (std::exception& e) {
81066       {
81067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81072       };
81073     }
81074   }
81075 }
81076
81077
81078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
81079   void * jresult ;
81080   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81081
81082   {
81083     try {
81084       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
81085     } catch (std::out_of_range& e) {
81086       {
81087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81088       };
81089     } catch (std::exception& e) {
81090       {
81091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81096       };
81097     }
81098   }
81099   jresult = (void *)result;
81100   return jresult;
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
81105   void * jresult ;
81106   unsigned int arg1 ;
81107   Dali::Actor arg2 ;
81108   Dali::Actor *argp2 ;
81109   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81110
81111   arg1 = (unsigned int)jarg1;
81112   argp2 = (Dali::Actor *)jarg2;
81113   if (!argp2) {
81114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81115     return 0;
81116   }
81117   arg2 = *argp2;
81118   {
81119     try {
81120       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
81121     } catch (std::out_of_range& e) {
81122       {
81123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81124       };
81125     } catch (std::exception& e) {
81126       {
81127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81128       };
81129     } catch (...) {
81130       {
81131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81132       };
81133     }
81134   }
81135   jresult = (void *)result;
81136   return jresult;
81137 }
81138
81139
81140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
81141   void * jresult ;
81142   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81143   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81144
81145   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81146   if (!arg1) {
81147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81148     return 0;
81149   }
81150   {
81151     try {
81152       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
81153     } catch (std::out_of_range& e) {
81154       {
81155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (std::exception& e) {
81158       {
81159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167   jresult = (void *)result;
81168   return jresult;
81169 }
81170
81171
81172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
81173   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81174   unsigned int arg2 ;
81175
81176   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81177   arg2 = (unsigned int)jarg2;
81178   if (arg1) (arg1)->first = arg2;
81179 }
81180
81181
81182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
81183   unsigned int jresult ;
81184   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81185   unsigned int result;
81186
81187   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81188   result = (unsigned int) ((arg1)->first);
81189   jresult = result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
81195   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81196   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
81197
81198   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81199   arg2 = (Dali::Actor *)jarg2;
81200   if (arg1) (arg1)->second = *arg2;
81201 }
81202
81203
81204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
81205   void * jresult ;
81206   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81207   Dali::Actor *result = 0 ;
81208
81209   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81210   result = (Dali::Actor *)& ((arg1)->second);
81211   jresult = (void *)result;
81212   return jresult;
81213 }
81214
81215
81216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
81217   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
81218
81219   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81220   {
81221     try {
81222       delete arg1;
81223     } catch (std::out_of_range& e) {
81224       {
81225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81226       };
81227     } catch (std::exception& e) {
81228       {
81229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81230       };
81231     } catch (...) {
81232       {
81233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81234       };
81235     }
81236   }
81237 }
81238
81239
81240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
81241   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81242
81243   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81244   {
81245     try {
81246       (arg1)->clear();
81247     } catch (std::out_of_range& e) {
81248       {
81249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81250       };
81251     } catch (std::exception& e) {
81252       {
81253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81254       };
81255     } catch (...) {
81256       {
81257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81258       };
81259     }
81260   }
81261 }
81262
81263
81264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
81265   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81266   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
81267
81268   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81269   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
81270   if (!arg2) {
81271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81272     return ;
81273   }
81274   {
81275     try {
81276       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
81277     } catch (std::out_of_range& e) {
81278       {
81279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81280       };
81281     } catch (std::exception& e) {
81282       {
81283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81284       };
81285     } catch (...) {
81286       {
81287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81288       };
81289     }
81290   }
81291 }
81292
81293
81294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
81295   unsigned long jresult ;
81296   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81297   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81298
81299   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81300   {
81301     try {
81302       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
81303     } catch (std::out_of_range& e) {
81304       {
81305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81306       };
81307     } catch (std::exception& e) {
81308       {
81309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81310       };
81311     } catch (...) {
81312       {
81313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81314       };
81315     }
81316   }
81317   jresult = (unsigned long)result;
81318   return jresult;
81319 }
81320
81321
81322 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
81323   unsigned long jresult ;
81324   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81325   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
81326
81327   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81328   {
81329     try {
81330       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
81331     } catch (std::out_of_range& e) {
81332       {
81333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81334       };
81335     } catch (std::exception& e) {
81336       {
81337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81338       };
81339     } catch (...) {
81340       {
81341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81342       };
81343     }
81344   }
81345   jresult = (unsigned long)result;
81346   return jresult;
81347 }
81348
81349
81350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
81351   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81352   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
81353
81354   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81355   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
81356   {
81357     try {
81358       (arg1)->reserve(arg2);
81359     } catch (std::out_of_range& e) {
81360       {
81361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81362       };
81363     } catch (std::exception& e) {
81364       {
81365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81370       };
81371     }
81372   }
81373 }
81374
81375
81376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
81377   void * jresult ;
81378   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81379
81380   {
81381     try {
81382       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
81383     } catch (std::out_of_range& e) {
81384       {
81385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81386       };
81387     } catch (std::exception& e) {
81388       {
81389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81394       };
81395     }
81396   }
81397   jresult = (void *)result;
81398   return jresult;
81399 }
81400
81401
81402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
81403   void * jresult ;
81404   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
81405   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81406
81407   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81408   if (!arg1) {
81409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81410     return 0;
81411   }
81412   {
81413     try {
81414       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);
81415     } catch (std::out_of_range& e) {
81416       {
81417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81418       };
81419     } catch (std::exception& e) {
81420       {
81421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81422       };
81423     } catch (...) {
81424       {
81425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81426       };
81427     }
81428   }
81429   jresult = (void *)result;
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
81435   void * jresult ;
81436   int arg1 ;
81437   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81438
81439   arg1 = (int)jarg1;
81440   {
81441     try {
81442       try {
81443         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);
81444       }
81445       catch(std::out_of_range &_e) {
81446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81447         return 0;
81448       }
81449
81450     } catch (std::out_of_range& e) {
81451       {
81452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81453       };
81454     } catch (std::exception& e) {
81455       {
81456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81457       };
81458     } catch (...) {
81459       {
81460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81461       };
81462     }
81463   }
81464   jresult = (void *)result;
81465   return jresult;
81466 }
81467
81468
81469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
81470   void * jresult ;
81471   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81472   int arg2 ;
81473   std::pair< unsigned int,Dali::Actor > result;
81474
81475   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81476   arg2 = (int)jarg2;
81477   {
81478     try {
81479       try {
81480         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
81481       }
81482       catch(std::out_of_range &_e) {
81483         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81484         return 0;
81485       }
81486
81487     } catch (std::out_of_range& e) {
81488       {
81489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81490       };
81491     } catch (std::exception& e) {
81492       {
81493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81494       };
81495     } catch (...) {
81496       {
81497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81498       };
81499     }
81500   }
81501   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
81502   return jresult;
81503 }
81504
81505
81506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
81507   void * jresult ;
81508   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81509   int arg2 ;
81510   std::pair< unsigned int,Dali::Actor > *result = 0 ;
81511
81512   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81513   arg2 = (int)jarg2;
81514   {
81515     try {
81516       try {
81517         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
81518       }
81519       catch(std::out_of_range &_e) {
81520         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81521         return 0;
81522       }
81523
81524     } catch (std::out_of_range& e) {
81525       {
81526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81527       };
81528     } catch (std::exception& e) {
81529       {
81530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81531       };
81532     } catch (...) {
81533       {
81534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81535       };
81536     }
81537   }
81538   jresult = (void *)result;
81539   return jresult;
81540 }
81541
81542
81543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
81544   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81545   int arg2 ;
81546   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81547
81548   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81549   arg2 = (int)jarg2;
81550   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81551   if (!arg3) {
81552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81553     return ;
81554   }
81555   {
81556     try {
81557       try {
81558         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);
81559       }
81560       catch(std::out_of_range &_e) {
81561         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81562         return ;
81563       }
81564
81565     } catch (std::out_of_range& e) {
81566       {
81567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81568       };
81569     } catch (std::exception& e) {
81570       {
81571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81572       };
81573     } catch (...) {
81574       {
81575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81576       };
81577     }
81578   }
81579 }
81580
81581
81582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
81583   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81584   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
81585
81586   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81587   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
81588   if (!arg2) {
81589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81590     return ;
81591   }
81592   {
81593     try {
81594       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);
81595     } catch (std::out_of_range& e) {
81596       {
81597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81598       };
81599     } catch (std::exception& e) {
81600       {
81601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81602       };
81603     } catch (...) {
81604       {
81605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81606       };
81607     }
81608   }
81609 }
81610
81611
81612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
81613   void * jresult ;
81614   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81615   int arg2 ;
81616   int arg3 ;
81617   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81618
81619   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81620   arg2 = (int)jarg2;
81621   arg3 = (int)jarg3;
81622   {
81623     try {
81624       try {
81625         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);
81626       }
81627       catch(std::out_of_range &_e) {
81628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81629         return 0;
81630       }
81631       catch(std::invalid_argument &_e) {
81632         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81633         return 0;
81634       }
81635
81636     } catch (std::out_of_range& e) {
81637       {
81638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81639       };
81640     } catch (std::exception& e) {
81641       {
81642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81643       };
81644     } catch (...) {
81645       {
81646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81647       };
81648     }
81649   }
81650   jresult = (void *)result;
81651   return jresult;
81652 }
81653
81654
81655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
81656   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81657   int arg2 ;
81658   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
81659
81660   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81661   arg2 = (int)jarg2;
81662   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
81663   if (!arg3) {
81664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81665     return ;
81666   }
81667   {
81668     try {
81669       try {
81670         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);
81671       }
81672       catch(std::out_of_range &_e) {
81673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81674         return ;
81675       }
81676
81677     } catch (std::out_of_range& e) {
81678       {
81679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81680       };
81681     } catch (std::exception& e) {
81682       {
81683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81684       };
81685     } catch (...) {
81686       {
81687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81688       };
81689     }
81690   }
81691 }
81692
81693
81694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
81695   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81696   int arg2 ;
81697   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81698
81699   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81700   arg2 = (int)jarg2;
81701   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81702   if (!arg3) {
81703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81704     return ;
81705   }
81706   {
81707     try {
81708       try {
81709         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);
81710       }
81711       catch(std::out_of_range &_e) {
81712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81713         return ;
81714       }
81715
81716     } catch (std::out_of_range& e) {
81717       {
81718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81719       };
81720     } catch (std::exception& e) {
81721       {
81722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81723       };
81724     } catch (...) {
81725       {
81726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81727       };
81728     }
81729   }
81730 }
81731
81732
81733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
81734   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81735   int arg2 ;
81736
81737   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81738   arg2 = (int)jarg2;
81739   {
81740     try {
81741       try {
81742         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
81743       }
81744       catch(std::out_of_range &_e) {
81745         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81746         return ;
81747       }
81748
81749     } catch (std::out_of_range& e) {
81750       {
81751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81752       };
81753     } catch (std::exception& e) {
81754       {
81755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81756       };
81757     } catch (...) {
81758       {
81759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81760       };
81761     }
81762   }
81763 }
81764
81765
81766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
81767   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81768   int arg2 ;
81769   int arg3 ;
81770
81771   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81772   arg2 = (int)jarg2;
81773   arg3 = (int)jarg3;
81774   {
81775     try {
81776       try {
81777         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
81778       }
81779       catch(std::out_of_range &_e) {
81780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81781         return ;
81782       }
81783       catch(std::invalid_argument &_e) {
81784         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81785         return ;
81786       }
81787
81788     } catch (std::out_of_range& e) {
81789       {
81790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81791       };
81792     } catch (std::exception& e) {
81793       {
81794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81795       };
81796     } catch (...) {
81797       {
81798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81799       };
81800     }
81801   }
81802 }
81803
81804
81805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
81806   void * jresult ;
81807   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
81808   int arg2 ;
81809   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
81810
81811   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
81812   if (!arg1) {
81813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
81814     return 0;
81815   }
81816   arg2 = (int)jarg2;
81817   {
81818     try {
81819       try {
81820         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);
81821       }
81822       catch(std::out_of_range &_e) {
81823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81824         return 0;
81825       }
81826
81827     } catch (std::out_of_range& e) {
81828       {
81829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81830       };
81831     } catch (std::exception& e) {
81832       {
81833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81834       };
81835     } catch (...) {
81836       {
81837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81838       };
81839     }
81840   }
81841   jresult = (void *)result;
81842   return jresult;
81843 }
81844
81845
81846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
81847   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81848
81849   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81850   {
81851     try {
81852       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
81853     } catch (std::out_of_range& e) {
81854       {
81855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81856       };
81857     } catch (std::exception& e) {
81858       {
81859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81860       };
81861     } catch (...) {
81862       {
81863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81864       };
81865     }
81866   }
81867 }
81868
81869
81870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
81871   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81872   int arg2 ;
81873   int arg3 ;
81874
81875   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81876   arg2 = (int)jarg2;
81877   arg3 = (int)jarg3;
81878   {
81879     try {
81880       try {
81881         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
81882       }
81883       catch(std::out_of_range &_e) {
81884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81885         return ;
81886       }
81887       catch(std::invalid_argument &_e) {
81888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
81889         return ;
81890       }
81891
81892     } catch (std::out_of_range& e) {
81893       {
81894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81895       };
81896     } catch (std::exception& e) {
81897       {
81898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81899       };
81900     } catch (...) {
81901       {
81902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81903       };
81904     }
81905   }
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
81910   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81911   int arg2 ;
81912   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
81913
81914   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81915   arg2 = (int)jarg2;
81916   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
81917   if (!arg3) {
81918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
81919     return ;
81920   }
81921   {
81922     try {
81923       try {
81924         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);
81925       }
81926       catch(std::out_of_range &_e) {
81927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
81928         return ;
81929       }
81930
81931     } catch (std::out_of_range& e) {
81932       {
81933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81934       };
81935     } catch (std::exception& e) {
81936       {
81937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81938       };
81939     } catch (...) {
81940       {
81941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81942       };
81943     }
81944   }
81945 }
81946
81947
81948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
81949   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
81950
81951   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
81952   {
81953     try {
81954       delete arg1;
81955     } catch (std::out_of_range& e) {
81956       {
81957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81958       };
81959     } catch (std::exception& e) {
81960       {
81961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81962       };
81963     } catch (...) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81966       };
81967     }
81968   }
81969 }
81970
81971
81972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
81973   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81974
81975   arg1 = (std::vector< Dali::Actor > *)jarg1;
81976   {
81977     try {
81978       (arg1)->clear();
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (...) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81990       };
81991     }
81992   }
81993 }
81994
81995
81996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
81997   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
81998   Dali::Actor *arg2 = 0 ;
81999
82000   arg1 = (std::vector< Dali::Actor > *)jarg1;
82001   arg2 = (Dali::Actor *)jarg2;
82002   if (!arg2) {
82003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82004     return ;
82005   }
82006   {
82007     try {
82008       (arg1)->push_back((Dali::Actor const &)*arg2);
82009     } catch (std::out_of_range& e) {
82010       {
82011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82012       };
82013     } catch (std::exception& e) {
82014       {
82015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82016       };
82017     } catch (...) {
82018       {
82019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82020       };
82021     }
82022   }
82023 }
82024
82025
82026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
82027   unsigned long jresult ;
82028   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82029   std::vector< Dali::Actor >::size_type result;
82030
82031   arg1 = (std::vector< Dali::Actor > *)jarg1;
82032   {
82033     try {
82034       result = ((std::vector< Dali::Actor > const *)arg1)->size();
82035     } catch (std::out_of_range& e) {
82036       {
82037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82038       };
82039     } catch (std::exception& e) {
82040       {
82041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82042       };
82043     } catch (...) {
82044       {
82045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82046       };
82047     }
82048   }
82049   jresult = (unsigned long)result;
82050   return jresult;
82051 }
82052
82053
82054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
82055   unsigned long jresult ;
82056   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82057   std::vector< Dali::Actor >::size_type result;
82058
82059   arg1 = (std::vector< Dali::Actor > *)jarg1;
82060   {
82061     try {
82062       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
82063     } catch (std::out_of_range& e) {
82064       {
82065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82066       };
82067     } catch (std::exception& e) {
82068       {
82069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82070       };
82071     } catch (...) {
82072       {
82073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82074       };
82075     }
82076   }
82077   jresult = (unsigned long)result;
82078   return jresult;
82079 }
82080
82081
82082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
82083   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82084   std::vector< Dali::Actor >::size_type arg2 ;
82085
82086   arg1 = (std::vector< Dali::Actor > *)jarg1;
82087   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
82088   {
82089     try {
82090       (arg1)->reserve(arg2);
82091     } catch (std::out_of_range& e) {
82092       {
82093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82094       };
82095     } catch (std::exception& e) {
82096       {
82097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82098       };
82099     } catch (...) {
82100       {
82101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82102       };
82103     }
82104   }
82105 }
82106
82107
82108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
82109   void * jresult ;
82110   std::vector< Dali::Actor > *result = 0 ;
82111
82112   {
82113     try {
82114       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
82115     } catch (std::out_of_range& e) {
82116       {
82117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82118       };
82119     } catch (std::exception& e) {
82120       {
82121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82122       };
82123     } catch (...) {
82124       {
82125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82126       };
82127     }
82128   }
82129   jresult = (void *)result;
82130   return jresult;
82131 }
82132
82133
82134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
82135   void * jresult ;
82136   std::vector< Dali::Actor > *arg1 = 0 ;
82137   std::vector< Dali::Actor > *result = 0 ;
82138
82139   arg1 = (std::vector< Dali::Actor > *)jarg1;
82140   if (!arg1) {
82141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82142     return 0;
82143   }
82144   {
82145     try {
82146       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
82147     } catch (std::out_of_range& e) {
82148       {
82149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82150       };
82151     } catch (std::exception& e) {
82152       {
82153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82154       };
82155     } catch (...) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82158       };
82159     }
82160   }
82161   jresult = (void *)result;
82162   return jresult;
82163 }
82164
82165
82166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
82167   void * jresult ;
82168   int arg1 ;
82169   std::vector< Dali::Actor > *result = 0 ;
82170
82171   arg1 = (int)jarg1;
82172   {
82173     try {
82174       try {
82175         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
82176       }
82177       catch(std::out_of_range &_e) {
82178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82179         return 0;
82180       }
82181
82182     } catch (std::out_of_range& e) {
82183       {
82184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82185       };
82186     } catch (std::exception& e) {
82187       {
82188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82189       };
82190     } catch (...) {
82191       {
82192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82193       };
82194     }
82195   }
82196   jresult = (void *)result;
82197   return jresult;
82198 }
82199
82200
82201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
82202   void * jresult ;
82203   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82204   int arg2 ;
82205   Dali::Actor result;
82206
82207   arg1 = (std::vector< Dali::Actor > *)jarg1;
82208   arg2 = (int)jarg2;
82209   {
82210     try {
82211       try {
82212         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
82213       }
82214       catch(std::out_of_range &_e) {
82215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82216         return 0;
82217       }
82218
82219     } catch (std::out_of_range& e) {
82220       {
82221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82222       };
82223     } catch (std::exception& e) {
82224       {
82225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (...) {
82228       {
82229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82230       };
82231     }
82232   }
82233   jresult = new Dali::Actor((const Dali::Actor &)result);
82234   return jresult;
82235 }
82236
82237
82238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
82239   void * jresult ;
82240   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82241   int arg2 ;
82242   Dali::Actor *result = 0 ;
82243
82244   arg1 = (std::vector< Dali::Actor > *)jarg1;
82245   arg2 = (int)jarg2;
82246   {
82247     try {
82248       try {
82249         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
82250       }
82251       catch(std::out_of_range &_e) {
82252         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82253         return 0;
82254       }
82255
82256     } catch (std::out_of_range& e) {
82257       {
82258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82259       };
82260     } catch (std::exception& e) {
82261       {
82262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82263       };
82264     } catch (...) {
82265       {
82266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82267       };
82268     }
82269   }
82270   jresult = (void *)result;
82271   return jresult;
82272 }
82273
82274
82275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
82276   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82277   int arg2 ;
82278   Dali::Actor *arg3 = 0 ;
82279
82280   arg1 = (std::vector< Dali::Actor > *)jarg1;
82281   arg2 = (int)jarg2;
82282   arg3 = (Dali::Actor *)jarg3;
82283   if (!arg3) {
82284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82285     return ;
82286   }
82287   {
82288     try {
82289       try {
82290         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
82291       }
82292       catch(std::out_of_range &_e) {
82293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82294         return ;
82295       }
82296
82297     } catch (std::out_of_range& e) {
82298       {
82299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82300       };
82301     } catch (std::exception& e) {
82302       {
82303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82304       };
82305     } catch (...) {
82306       {
82307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82308       };
82309     }
82310   }
82311 }
82312
82313
82314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
82315   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82316   std::vector< Dali::Actor > *arg2 = 0 ;
82317
82318   arg1 = (std::vector< Dali::Actor > *)jarg1;
82319   arg2 = (std::vector< Dali::Actor > *)jarg2;
82320   if (!arg2) {
82321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82322     return ;
82323   }
82324   {
82325     try {
82326       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82334       };
82335     } catch (...) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82338       };
82339     }
82340   }
82341 }
82342
82343
82344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82345   void * jresult ;
82346   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82347   int arg2 ;
82348   int arg3 ;
82349   std::vector< Dali::Actor > *result = 0 ;
82350
82351   arg1 = (std::vector< Dali::Actor > *)jarg1;
82352   arg2 = (int)jarg2;
82353   arg3 = (int)jarg3;
82354   {
82355     try {
82356       try {
82357         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
82358       }
82359       catch(std::out_of_range &_e) {
82360         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82361         return 0;
82362       }
82363       catch(std::invalid_argument &_e) {
82364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82365         return 0;
82366       }
82367
82368     } catch (std::out_of_range& e) {
82369       {
82370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82371       };
82372     } catch (std::exception& e) {
82373       {
82374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82375       };
82376     } catch (...) {
82377       {
82378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82379       };
82380     }
82381   }
82382   jresult = (void *)result;
82383   return jresult;
82384 }
82385
82386
82387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
82388   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82389   int arg2 ;
82390   Dali::Actor *arg3 = 0 ;
82391
82392   arg1 = (std::vector< Dali::Actor > *)jarg1;
82393   arg2 = (int)jarg2;
82394   arg3 = (Dali::Actor *)jarg3;
82395   if (!arg3) {
82396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82397     return ;
82398   }
82399   {
82400     try {
82401       try {
82402         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
82403       }
82404       catch(std::out_of_range &_e) {
82405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82406         return ;
82407       }
82408
82409     } catch (std::out_of_range& e) {
82410       {
82411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82412       };
82413     } catch (std::exception& e) {
82414       {
82415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82416       };
82417     } catch (...) {
82418       {
82419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82420       };
82421     }
82422   }
82423 }
82424
82425
82426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82427   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82428   int arg2 ;
82429   std::vector< Dali::Actor > *arg3 = 0 ;
82430
82431   arg1 = (std::vector< Dali::Actor > *)jarg1;
82432   arg2 = (int)jarg2;
82433   arg3 = (std::vector< Dali::Actor > *)jarg3;
82434   if (!arg3) {
82435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82436     return ;
82437   }
82438   {
82439     try {
82440       try {
82441         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82442       }
82443       catch(std::out_of_range &_e) {
82444         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82445         return ;
82446       }
82447
82448     } catch (std::out_of_range& e) {
82449       {
82450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82451       };
82452     } catch (std::exception& e) {
82453       {
82454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82455       };
82456     } catch (...) {
82457       {
82458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82459       };
82460     }
82461   }
82462 }
82463
82464
82465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
82466   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82467   int arg2 ;
82468
82469   arg1 = (std::vector< Dali::Actor > *)jarg1;
82470   arg2 = (int)jarg2;
82471   {
82472     try {
82473       try {
82474         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
82475       }
82476       catch(std::out_of_range &_e) {
82477         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82478         return ;
82479       }
82480
82481     } catch (std::out_of_range& e) {
82482       {
82483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82484       };
82485     } catch (std::exception& e) {
82486       {
82487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82488       };
82489     } catch (...) {
82490       {
82491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82492       };
82493     }
82494   }
82495 }
82496
82497
82498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82499   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82500   int arg2 ;
82501   int arg3 ;
82502
82503   arg1 = (std::vector< Dali::Actor > *)jarg1;
82504   arg2 = (int)jarg2;
82505   arg3 = (int)jarg3;
82506   {
82507     try {
82508       try {
82509         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
82510       }
82511       catch(std::out_of_range &_e) {
82512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82513         return ;
82514       }
82515       catch(std::invalid_argument &_e) {
82516         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82517         return ;
82518       }
82519
82520     } catch (std::out_of_range& e) {
82521       {
82522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82523       };
82524     } catch (std::exception& e) {
82525       {
82526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82527       };
82528     } catch (...) {
82529       {
82530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82531       };
82532     }
82533   }
82534 }
82535
82536
82537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
82538   void * jresult ;
82539   Dali::Actor *arg1 = 0 ;
82540   int arg2 ;
82541   std::vector< Dali::Actor > *result = 0 ;
82542
82543   arg1 = (Dali::Actor *)jarg1;
82544   if (!arg1) {
82545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
82546     return 0;
82547   }
82548   arg2 = (int)jarg2;
82549   {
82550     try {
82551       try {
82552         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
82553       }
82554       catch(std::out_of_range &_e) {
82555         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82556         return 0;
82557       }
82558
82559     } catch (std::out_of_range& e) {
82560       {
82561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82562       };
82563     } catch (std::exception& e) {
82564       {
82565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82566       };
82567     } catch (...) {
82568       {
82569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82570       };
82571     }
82572   }
82573   jresult = (void *)result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
82579   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82580
82581   arg1 = (std::vector< Dali::Actor > *)jarg1;
82582   {
82583     try {
82584       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
82585     } catch (std::out_of_range& e) {
82586       {
82587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82588       };
82589     } catch (std::exception& e) {
82590       {
82591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82592       };
82593     } catch (...) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82596       };
82597     }
82598   }
82599 }
82600
82601
82602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82603   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82604   int arg2 ;
82605   int arg3 ;
82606
82607   arg1 = (std::vector< Dali::Actor > *)jarg1;
82608   arg2 = (int)jarg2;
82609   arg3 = (int)jarg3;
82610   {
82611     try {
82612       try {
82613         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82614       }
82615       catch(std::out_of_range &_e) {
82616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82617         return ;
82618       }
82619       catch(std::invalid_argument &_e) {
82620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82621         return ;
82622       }
82623
82624     } catch (std::out_of_range& e) {
82625       {
82626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82627       };
82628     } catch (std::exception& e) {
82629       {
82630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82631       };
82632     } catch (...) {
82633       {
82634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82635       };
82636     }
82637   }
82638 }
82639
82640
82641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82642   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82643   int arg2 ;
82644   std::vector< Dali::Actor > *arg3 = 0 ;
82645
82646   arg1 = (std::vector< Dali::Actor > *)jarg1;
82647   arg2 = (int)jarg2;
82648   arg3 = (std::vector< Dali::Actor > *)jarg3;
82649   if (!arg3) {
82650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
82651     return ;
82652   }
82653   {
82654     try {
82655       try {
82656         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
82657       }
82658       catch(std::out_of_range &_e) {
82659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82660         return ;
82661       }
82662
82663     } catch (std::out_of_range& e) {
82664       {
82665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82666       };
82667     } catch (std::exception& e) {
82668       {
82669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82670       };
82671     } catch (...) {
82672       {
82673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82674       };
82675     }
82676   }
82677 }
82678
82679
82680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
82681   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
82682
82683   arg1 = (std::vector< Dali::Actor > *)jarg1;
82684   {
82685     try {
82686       delete arg1;
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82694       };
82695     } catch (...) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82698       };
82699     }
82700   }
82701 }
82702
82703
82704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
82705   unsigned int jresult ;
82706   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82707   bool result;
82708
82709   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82710   {
82711     try {
82712       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82713     } catch (std::out_of_range& e) {
82714       {
82715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82716       };
82717     } catch (std::exception& e) {
82718       {
82719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82720       };
82721     } catch (...) {
82722       {
82723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82724       };
82725     }
82726   }
82727   jresult = result;
82728   return jresult;
82729 }
82730
82731
82732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
82733   unsigned long jresult ;
82734   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82735   std::size_t result;
82736
82737   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82738   {
82739     try {
82740       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
82741     } catch (std::out_of_range& e) {
82742       {
82743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82744       };
82745     } catch (std::exception& e) {
82746       {
82747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82748       };
82749     } catch (...) {
82750       {
82751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82752       };
82753     }
82754   }
82755   jresult = (unsigned long)result;
82756   return jresult;
82757 }
82758
82759
82760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
82761   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82762   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82763
82764   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82765   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82766   {
82767     try {
82768       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
82769     } catch (std::out_of_range& e) {
82770       {
82771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82772       };
82773     } catch (std::exception& e) {
82774       {
82775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82776       };
82777     } catch (...) {
82778       {
82779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82780       };
82781     }
82782   }
82783 }
82784
82785
82786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
82787   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82788   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
82789
82790   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82791   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
82792   {
82793     try {
82794       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
82795     } catch (std::out_of_range& e) {
82796       {
82797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82798       };
82799     } catch (std::exception& e) {
82800       {
82801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82806       };
82807     }
82808   }
82809 }
82810
82811
82812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
82813   unsigned int jresult ;
82814   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82815   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
82816   bool result;
82817
82818   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82819   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
82820   if (!arg2) {
82821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
82822     return 0;
82823   }
82824   {
82825     try {
82826       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
82827     } catch (std::out_of_range& e) {
82828       {
82829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82830       };
82831     } catch (std::exception& e) {
82832       {
82833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82834       };
82835     } catch (...) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82838       };
82839     }
82840   }
82841   jresult = result;
82842   return jresult;
82843 }
82844
82845
82846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
82847   void * jresult ;
82848   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
82849
82850   {
82851     try {
82852       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
82853     } catch (std::out_of_range& e) {
82854       {
82855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82856       };
82857     } catch (std::exception& e) {
82858       {
82859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82860       };
82861     } catch (...) {
82862       {
82863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82864       };
82865     }
82866   }
82867   jresult = (void *)result;
82868   return jresult;
82869 }
82870
82871
82872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
82873   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
82874
82875   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
82876   {
82877     try {
82878       delete arg1;
82879     } catch (std::out_of_range& e) {
82880       {
82881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82882       };
82883     } catch (std::exception& e) {
82884       {
82885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82886       };
82887     } catch (...) {
82888       {
82889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82890       };
82891     }
82892   }
82893 }
82894
82895
82896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
82897   unsigned int jresult ;
82898   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82899   bool result;
82900
82901   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82902   {
82903     try {
82904       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);
82905     } catch (std::out_of_range& e) {
82906       {
82907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (std::exception& e) {
82910       {
82911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82912       };
82913     } catch (...) {
82914       {
82915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82916       };
82917     }
82918   }
82919   jresult = result;
82920   return jresult;
82921 }
82922
82923
82924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
82925   unsigned long jresult ;
82926   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82927   std::size_t result;
82928
82929   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82930   {
82931     try {
82932       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);
82933     } catch (std::out_of_range& e) {
82934       {
82935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82936       };
82937     } catch (std::exception& e) {
82938       {
82939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82940       };
82941     } catch (...) {
82942       {
82943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82944       };
82945     }
82946   }
82947   jresult = (unsigned long)result;
82948   return jresult;
82949 }
82950
82951
82952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
82953   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82954   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82955
82956   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82957   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82958   {
82959     try {
82960       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
82961     } catch (std::out_of_range& e) {
82962       {
82963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82964       };
82965     } catch (std::exception& e) {
82966       {
82967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82968       };
82969     } catch (...) {
82970       {
82971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82972       };
82973     }
82974   }
82975 }
82976
82977
82978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
82979   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
82980   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
82981
82982   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
82983   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
82984   {
82985     try {
82986       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (...) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82998       };
82999     }
83000   }
83001 }
83002
83003
83004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83005   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83006   Dali::Actor arg2 ;
83007   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
83008   Dali::Actor *argp2 ;
83009
83010   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83011   argp2 = (Dali::Actor *)jarg2;
83012   if (!argp2) {
83013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83014     return ;
83015   }
83016   arg2 = *argp2;
83017   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
83018   {
83019     try {
83020       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
83021     } catch (std::out_of_range& e) {
83022       {
83023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83024       };
83025     } catch (std::exception& e) {
83026       {
83027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83028       };
83029     } catch (...) {
83030       {
83031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83032       };
83033     }
83034   }
83035 }
83036
83037
83038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
83039   void * jresult ;
83040   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
83041
83042   {
83043     try {
83044       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
83045     } catch (std::out_of_range& e) {
83046       {
83047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83048       };
83049     } catch (std::exception& e) {
83050       {
83051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (...) {
83054       {
83055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83056       };
83057     }
83058   }
83059   jresult = (void *)result;
83060   return jresult;
83061 }
83062
83063
83064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
83065   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
83066
83067   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
83068   {
83069     try {
83070       delete arg1;
83071     } catch (std::out_of_range& e) {
83072       {
83073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83074       };
83075     } catch (std::exception& e) {
83076       {
83077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83078       };
83079     } catch (...) {
83080       {
83081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83082       };
83083     }
83084   }
83085 }
83086
83087
83088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
83089   unsigned int jresult ;
83090   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83091   bool result;
83092
83093   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83094   {
83095     try {
83096       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
83097     } catch (std::out_of_range& e) {
83098       {
83099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83100       };
83101     } catch (std::exception& e) {
83102       {
83103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83104       };
83105     } catch (...) {
83106       {
83107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83108       };
83109     }
83110   }
83111   jresult = result;
83112   return jresult;
83113 }
83114
83115
83116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
83117   unsigned long jresult ;
83118   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83119   std::size_t result;
83120
83121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83122   {
83123     try {
83124       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
83125     } catch (std::out_of_range& e) {
83126       {
83127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83128       };
83129     } catch (std::exception& e) {
83130       {
83131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (...) {
83134       {
83135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83136       };
83137     }
83138   }
83139   jresult = (unsigned long)result;
83140   return jresult;
83141 }
83142
83143
83144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
83145   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83146   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83147
83148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83149   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83150   {
83151     try {
83152       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83164       };
83165     }
83166   }
83167 }
83168
83169
83170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83171   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83172   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
83173
83174   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83175   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
83176   {
83177     try {
83178       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
83179     } catch (std::out_of_range& e) {
83180       {
83181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83182       };
83183     } catch (std::exception& e) {
83184       {
83185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83186       };
83187     } catch (...) {
83188       {
83189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83190       };
83191     }
83192   }
83193 }
83194
83195
83196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
83197   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83198   Dali::Actor arg2 ;
83199   Dali::Actor arg3 ;
83200   Dali::Actor *argp2 ;
83201   Dali::Actor *argp3 ;
83202
83203   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83204   argp2 = (Dali::Actor *)jarg2;
83205   if (!argp2) {
83206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83207     return ;
83208   }
83209   arg2 = *argp2;
83210   argp3 = (Dali::Actor *)jarg3;
83211   if (!argp3) {
83212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83213     return ;
83214   }
83215   arg3 = *argp3;
83216   {
83217     try {
83218       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
83219     } catch (std::out_of_range& e) {
83220       {
83221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83222       };
83223     } catch (std::exception& e) {
83224       {
83225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83226       };
83227     } catch (...) {
83228       {
83229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83230       };
83231     }
83232   }
83233 }
83234
83235
83236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
83237   void * jresult ;
83238   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
83239
83240   {
83241     try {
83242       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
83243     } catch (std::out_of_range& e) {
83244       {
83245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (std::exception& e) {
83248       {
83249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83254       };
83255     }
83256   }
83257   jresult = (void *)result;
83258   return jresult;
83259 }
83260
83261
83262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
83263   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
83264
83265   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
83266   {
83267     try {
83268       delete arg1;
83269     } catch (std::out_of_range& e) {
83270       {
83271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83272       };
83273     } catch (std::exception& e) {
83274       {
83275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83276       };
83277     } catch (...) {
83278       {
83279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83280       };
83281     }
83282   }
83283 }
83284
83285
83286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
83287   unsigned int jresult ;
83288   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83289   bool result;
83290
83291   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83292   {
83293     try {
83294       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83295     } catch (std::out_of_range& e) {
83296       {
83297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83298       };
83299     } catch (std::exception& e) {
83300       {
83301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83302       };
83303     } catch (...) {
83304       {
83305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83306       };
83307     }
83308   }
83309   jresult = result;
83310   return jresult;
83311 }
83312
83313
83314 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
83315   unsigned long jresult ;
83316   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83317   std::size_t result;
83318
83319   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83320   {
83321     try {
83322       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
83323     } catch (std::out_of_range& e) {
83324       {
83325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83326       };
83327     } catch (std::exception& e) {
83328       {
83329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83330       };
83331     } catch (...) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83334       };
83335     }
83336   }
83337   jresult = (unsigned long)result;
83338   return jresult;
83339 }
83340
83341
83342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
83343   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83344   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83345
83346   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83347   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83348   {
83349     try {
83350       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
83351     } catch (std::out_of_range& e) {
83352       {
83353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83354       };
83355     } catch (std::exception& e) {
83356       {
83357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83358       };
83359     } catch (...) {
83360       {
83361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83362       };
83363     }
83364   }
83365 }
83366
83367
83368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83369   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83370   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
83371
83372   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83373   arg2 = (void (*)(Dali::Actor,bool))jarg2;
83374   {
83375     try {
83376       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
83377     } catch (std::out_of_range& e) {
83378       {
83379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83380       };
83381     } catch (std::exception& e) {
83382       {
83383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83384       };
83385     } catch (...) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83388       };
83389     }
83390   }
83391 }
83392
83393
83394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
83395   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83396   Dali::Actor arg2 ;
83397   bool arg3 ;
83398   Dali::Actor *argp2 ;
83399
83400   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83401   argp2 = (Dali::Actor *)jarg2;
83402   if (!argp2) {
83403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83404     return ;
83405   }
83406   arg2 = *argp2;
83407   arg3 = jarg3 ? true : false;
83408   {
83409     try {
83410       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
83411     } catch (std::out_of_range& e) {
83412       {
83413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83414       };
83415     } catch (std::exception& e) {
83416       {
83417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83418       };
83419     } catch (...) {
83420       {
83421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83422       };
83423     }
83424   }
83425 }
83426
83427
83428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
83429   void * jresult ;
83430   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
83431
83432   {
83433     try {
83434       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
83435     } catch (std::out_of_range& e) {
83436       {
83437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83438       };
83439     } catch (std::exception& e) {
83440       {
83441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83442       };
83443     } catch (...) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83446       };
83447     }
83448   }
83449   jresult = (void *)result;
83450   return jresult;
83451 }
83452
83453
83454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
83455   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
83456
83457   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
83458   {
83459     try {
83460       delete arg1;
83461     } catch (std::out_of_range& e) {
83462       {
83463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83464       };
83465     } catch (std::exception& e) {
83466       {
83467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83468       };
83469     } catch (...) {
83470       {
83471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83472       };
83473     }
83474   }
83475 }
83476
83477
83478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
83479   unsigned int jresult ;
83480   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83481   bool result;
83482
83483   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83484   {
83485     try {
83486       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);
83487     } catch (std::out_of_range& e) {
83488       {
83489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83490       };
83491     } catch (std::exception& e) {
83492       {
83493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (...) {
83496       {
83497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83498       };
83499     }
83500   }
83501   jresult = result;
83502   return jresult;
83503 }
83504
83505
83506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
83507   unsigned long jresult ;
83508   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83509   std::size_t result;
83510
83511   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83512   {
83513     try {
83514       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);
83515     } catch (std::out_of_range& e) {
83516       {
83517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (std::exception& e) {
83520       {
83521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83522       };
83523     } catch (...) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83526       };
83527     }
83528   }
83529   jresult = (unsigned long)result;
83530   return jresult;
83531 }
83532
83533
83534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
83535   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83536   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83537
83538   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83539   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83540   {
83541     try {
83542       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
83543     } catch (std::out_of_range& e) {
83544       {
83545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83546       };
83547     } catch (std::exception& e) {
83548       {
83549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (...) {
83552       {
83553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83554       };
83555     }
83556   }
83557 }
83558
83559
83560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
83561   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83562   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
83563
83564   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83565   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
83566   {
83567     try {
83568       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
83569     } catch (std::out_of_range& e) {
83570       {
83571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83572       };
83573     } catch (std::exception& e) {
83574       {
83575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83576       };
83577     } catch (...) {
83578       {
83579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83580       };
83581     }
83582   }
83583 }
83584
83585
83586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
83587   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83588   Dali::Toolkit::StyleManager arg2 ;
83589   Dali::StyleChange::Type arg3 ;
83590   Dali::Toolkit::StyleManager *argp2 ;
83591
83592   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83593   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
83594   if (!argp2) {
83595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
83596     return ;
83597   }
83598   arg2 = *argp2;
83599   arg3 = (Dali::StyleChange::Type)jarg3;
83600   {
83601     try {
83602       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
83603     } catch (std::out_of_range& e) {
83604       {
83605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83606       };
83607     } catch (std::exception& e) {
83608       {
83609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83610       };
83611     } catch (...) {
83612       {
83613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83614       };
83615     }
83616   }
83617 }
83618
83619
83620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
83621   void * jresult ;
83622   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
83623
83624   {
83625     try {
83626       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
83627     } catch (std::out_of_range& e) {
83628       {
83629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83630       };
83631     } catch (std::exception& e) {
83632       {
83633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83634       };
83635     } catch (...) {
83636       {
83637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83638       };
83639     }
83640   }
83641   jresult = (void *)result;
83642   return jresult;
83643 }
83644
83645
83646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
83647   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
83648
83649   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
83650   {
83651     try {
83652       delete arg1;
83653     } catch (std::out_of_range& e) {
83654       {
83655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83656       };
83657     } catch (std::exception& e) {
83658       {
83659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83664       };
83665     }
83666   }
83667 }
83668
83669
83670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
83671   unsigned int jresult ;
83672   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83673   bool result;
83674
83675   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83676   {
83677     try {
83678       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83679     } catch (std::out_of_range& e) {
83680       {
83681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83682       };
83683     } catch (std::exception& e) {
83684       {
83685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83686       };
83687     } catch (...) {
83688       {
83689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83690       };
83691     }
83692   }
83693   jresult = result;
83694   return jresult;
83695 }
83696
83697
83698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
83699   unsigned long jresult ;
83700   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83701   std::size_t result;
83702
83703   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83704   {
83705     try {
83706       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
83707     } catch (std::out_of_range& e) {
83708       {
83709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83710       };
83711     } catch (std::exception& e) {
83712       {
83713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83714       };
83715     } catch (...) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83718       };
83719     }
83720   }
83721   jresult = (unsigned long)result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
83727   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83728   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83729
83730   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83731   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83732   {
83733     try {
83734       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
83735     } catch (std::out_of_range& e) {
83736       {
83737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83738       };
83739     } catch (std::exception& e) {
83740       {
83741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83742       };
83743     } catch (...) {
83744       {
83745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83746       };
83747     }
83748   }
83749 }
83750
83751
83752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
83753   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83754   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
83755
83756   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83757   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
83758   {
83759     try {
83760       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
83761     } catch (std::out_of_range& e) {
83762       {
83763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83764       };
83765     } catch (std::exception& e) {
83766       {
83767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83772       };
83773     }
83774   }
83775 }
83776
83777
83778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
83779   unsigned int jresult ;
83780   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83781   Dali::Toolkit::Button arg2 ;
83782   Dali::Toolkit::Button *argp2 ;
83783   bool result;
83784
83785   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83786   argp2 = (Dali::Toolkit::Button *)jarg2;
83787   if (!argp2) {
83788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
83789     return 0;
83790   }
83791   arg2 = *argp2;
83792   {
83793     try {
83794       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
83795     } catch (std::out_of_range& e) {
83796       {
83797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (std::exception& e) {
83800       {
83801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83806       };
83807     }
83808   }
83809   jresult = result;
83810   return jresult;
83811 }
83812
83813
83814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
83815   void * jresult ;
83816   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
83817
83818   {
83819     try {
83820       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83828       };
83829     } catch (...) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83832       };
83833     }
83834   }
83835   jresult = (void *)result;
83836   return jresult;
83837 }
83838
83839
83840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
83841   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
83842
83843   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
83844   {
83845     try {
83846       delete arg1;
83847     } catch (std::out_of_range& e) {
83848       {
83849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83850       };
83851     } catch (std::exception& e) {
83852       {
83853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83854       };
83855     } catch (...) {
83856       {
83857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83858       };
83859     }
83860   }
83861 }
83862
83863
83864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
83865   unsigned int jresult ;
83866   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83867   bool result;
83868
83869   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83870   {
83871     try {
83872       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83873     } catch (std::out_of_range& e) {
83874       {
83875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83876       };
83877     } catch (std::exception& e) {
83878       {
83879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83880       };
83881     } catch (...) {
83882       {
83883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83884       };
83885     }
83886   }
83887   jresult = result;
83888   return jresult;
83889 }
83890
83891
83892 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
83893   unsigned long jresult ;
83894   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83895   std::size_t result;
83896
83897   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83898   {
83899     try {
83900       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
83901     } catch (std::out_of_range& e) {
83902       {
83903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (std::exception& e) {
83906       {
83907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83908       };
83909     } catch (...) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83912       };
83913     }
83914   }
83915   jresult = (unsigned long)result;
83916   return jresult;
83917 }
83918
83919
83920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
83921   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83922   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83923
83924   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83925   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83926   {
83927     try {
83928       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
83929     } catch (std::out_of_range& e) {
83930       {
83931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83932       };
83933     } catch (std::exception& e) {
83934       {
83935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83936       };
83937     } catch (...) {
83938       {
83939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83940       };
83941     }
83942   }
83943 }
83944
83945
83946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
83947   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83948   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
83949
83950   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83951   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
83952   {
83953     try {
83954       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
83955     } catch (std::out_of_range& e) {
83956       {
83957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83958       };
83959     } catch (std::exception& e) {
83960       {
83961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83962       };
83963     } catch (...) {
83964       {
83965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83966       };
83967     }
83968   }
83969 }
83970
83971
83972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
83973   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
83974   Dali::Toolkit::GaussianBlurView arg2 ;
83975   Dali::Toolkit::GaussianBlurView *argp2 ;
83976
83977   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
83978   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83979   if (!argp2) {
83980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
83981     return ;
83982   }
83983   arg2 = *argp2;
83984   {
83985     try {
83986       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
83987     } catch (std::out_of_range& e) {
83988       {
83989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83990       };
83991     } catch (std::exception& e) {
83992       {
83993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83994       };
83995     } catch (...) {
83996       {
83997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83998       };
83999     }
84000   }
84001 }
84002
84003
84004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
84005   void * jresult ;
84006   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
84007
84008   {
84009     try {
84010       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
84011     } catch (std::out_of_range& e) {
84012       {
84013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84014       };
84015     } catch (std::exception& e) {
84016       {
84017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84018       };
84019     } catch (...) {
84020       {
84021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84022       };
84023     }
84024   }
84025   jresult = (void *)result;
84026   return jresult;
84027 }
84028
84029
84030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
84031   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
84032
84033   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
84034   {
84035     try {
84036       delete arg1;
84037     } catch (std::out_of_range& e) {
84038       {
84039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84040       };
84041     } catch (std::exception& e) {
84042       {
84043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84044       };
84045     } catch (...) {
84046       {
84047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84048       };
84049     }
84050   }
84051 }
84052
84053
84054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
84055   unsigned int jresult ;
84056   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84057   bool result;
84058
84059   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84060   {
84061     try {
84062       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);
84063     } catch (std::out_of_range& e) {
84064       {
84065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84066       };
84067     } catch (std::exception& e) {
84068       {
84069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84070       };
84071     } catch (...) {
84072       {
84073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84074       };
84075     }
84076   }
84077   jresult = result;
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
84083   unsigned long jresult ;
84084   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84085   std::size_t result;
84086
84087   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84088   {
84089     try {
84090       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);
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84098       };
84099     } catch (...) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84102       };
84103     }
84104   }
84105   jresult = (unsigned long)result;
84106   return jresult;
84107 }
84108
84109
84110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
84111   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84112   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
84113
84114   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84115   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
84116   {
84117     try {
84118       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
84119     } catch (std::out_of_range& e) {
84120       {
84121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84122       };
84123     } catch (std::exception& e) {
84124       {
84125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84126       };
84127     } catch (...) {
84128       {
84129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84130       };
84131     }
84132   }
84133 }
84134
84135
84136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
84137   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84138   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
84139
84140   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84141   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
84142   {
84143     try {
84144       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
84145     } catch (std::out_of_range& e) {
84146       {
84147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84148       };
84149     } catch (std::exception& e) {
84150       {
84151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84152       };
84153     } catch (...) {
84154       {
84155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84156       };
84157     }
84158   }
84159 }
84160
84161
84162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
84163   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84164   Dali::Toolkit::PageTurnView arg2 ;
84165   unsigned int arg3 ;
84166   bool arg4 ;
84167   Dali::Toolkit::PageTurnView *argp2 ;
84168
84169   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84170   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84171   if (!argp2) {
84172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84173     return ;
84174   }
84175   arg2 = *argp2;
84176   arg3 = (unsigned int)jarg3;
84177   arg4 = jarg4 ? true : false;
84178   {
84179     try {
84180       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84181     } catch (std::out_of_range& e) {
84182       {
84183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84184       };
84185     } catch (std::exception& e) {
84186       {
84187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (...) {
84190       {
84191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84192       };
84193     }
84194   }
84195 }
84196
84197
84198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
84199   void * jresult ;
84200   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
84201
84202   {
84203     try {
84204       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
84205     } catch (std::out_of_range& e) {
84206       {
84207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84208       };
84209     } catch (std::exception& e) {
84210       {
84211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84212       };
84213     } catch (...) {
84214       {
84215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84216       };
84217     }
84218   }
84219   jresult = (void *)result;
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
84225   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
84226
84227   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
84228   {
84229     try {
84230       delete arg1;
84231     } catch (std::out_of_range& e) {
84232       {
84233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84234       };
84235     } catch (std::exception& e) {
84236       {
84237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84238       };
84239     } catch (...) {
84240       {
84241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84242       };
84243     }
84244   }
84245 }
84246
84247
84248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
84249   unsigned int jresult ;
84250   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84251   bool result;
84252
84253   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84254   {
84255     try {
84256       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84257     } catch (std::out_of_range& e) {
84258       {
84259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84260       };
84261     } catch (std::exception& e) {
84262       {
84263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84264       };
84265     } catch (...) {
84266       {
84267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84268       };
84269     }
84270   }
84271   jresult = result;
84272   return jresult;
84273 }
84274
84275
84276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
84277   unsigned long jresult ;
84278   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84279   std::size_t result;
84280
84281   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84282   {
84283     try {
84284       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
84285     } catch (std::out_of_range& e) {
84286       {
84287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84288       };
84289     } catch (std::exception& e) {
84290       {
84291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (...) {
84294       {
84295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84296       };
84297     }
84298   }
84299   jresult = (unsigned long)result;
84300   return jresult;
84301 }
84302
84303
84304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
84305   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84306   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84307
84308   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84309   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84310   {
84311     try {
84312       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
84313     } catch (std::out_of_range& e) {
84314       {
84315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84316       };
84317     } catch (std::exception& e) {
84318       {
84319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84320       };
84321     } catch (...) {
84322       {
84323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84324       };
84325     }
84326   }
84327 }
84328
84329
84330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
84331   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84332   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
84333
84334   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84335   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
84336   {
84337     try {
84338       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
84339     } catch (std::out_of_range& e) {
84340       {
84341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84342       };
84343     } catch (std::exception& e) {
84344       {
84345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84346       };
84347     } catch (...) {
84348       {
84349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84350       };
84351     }
84352   }
84353 }
84354
84355
84356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
84357   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84358   Dali::Toolkit::PageTurnView arg2 ;
84359   Dali::Toolkit::PageTurnView *argp2 ;
84360
84361   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84362   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
84363   if (!argp2) {
84364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
84365     return ;
84366   }
84367   arg2 = *argp2;
84368   {
84369     try {
84370       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
84371     } catch (std::out_of_range& e) {
84372       {
84373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84374       };
84375     } catch (std::exception& e) {
84376       {
84377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84378       };
84379     } catch (...) {
84380       {
84381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84382       };
84383     }
84384   }
84385 }
84386
84387
84388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
84389   void * jresult ;
84390   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
84391
84392   {
84393     try {
84394       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
84395     } catch (std::out_of_range& e) {
84396       {
84397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84398       };
84399     } catch (std::exception& e) {
84400       {
84401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84402       };
84403     } catch (...) {
84404       {
84405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84406       };
84407     }
84408   }
84409   jresult = (void *)result;
84410   return jresult;
84411 }
84412
84413
84414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
84415   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
84416
84417   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
84418   {
84419     try {
84420       delete arg1;
84421     } catch (std::out_of_range& e) {
84422       {
84423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84424       };
84425     } catch (std::exception& e) {
84426       {
84427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84428       };
84429     } catch (...) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84432       };
84433     }
84434   }
84435 }
84436
84437
84438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
84439   unsigned int jresult ;
84440   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84441   bool result;
84442
84443   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84444   {
84445     try {
84446       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);
84447     } catch (std::out_of_range& e) {
84448       {
84449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84450       };
84451     } catch (std::exception& e) {
84452       {
84453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84454       };
84455     } catch (...) {
84456       {
84457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84458       };
84459     }
84460   }
84461   jresult = result;
84462   return jresult;
84463 }
84464
84465
84466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
84467   unsigned long jresult ;
84468   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84469   std::size_t result;
84470
84471   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84472   {
84473     try {
84474       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);
84475     } catch (std::out_of_range& e) {
84476       {
84477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (std::exception& e) {
84480       {
84481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (...) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84486       };
84487     }
84488   }
84489   jresult = (unsigned long)result;
84490   return jresult;
84491 }
84492
84493
84494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
84495   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84496   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84497
84498   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84499   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84500   {
84501     try {
84502       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84514       };
84515     }
84516   }
84517 }
84518
84519
84520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
84521   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84522   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
84523
84524   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84525   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
84526   {
84527     try {
84528       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
84529     } catch (std::out_of_range& e) {
84530       {
84531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84532       };
84533     } catch (std::exception& e) {
84534       {
84535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84536       };
84537     } catch (...) {
84538       {
84539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84540       };
84541     }
84542   }
84543 }
84544
84545
84546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
84547   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84548   Dali::Toolkit::ProgressBar arg2 ;
84549   float arg3 ;
84550   float arg4 ;
84551   Dali::Toolkit::ProgressBar *argp2 ;
84552
84553   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84554   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
84555   if (!argp2) {
84556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
84557     return ;
84558   }
84559   arg2 = *argp2;
84560   arg3 = (float)jarg3;
84561   arg4 = (float)jarg4;
84562   {
84563     try {
84564       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
84565     } catch (std::out_of_range& e) {
84566       {
84567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84568       };
84569     } catch (std::exception& e) {
84570       {
84571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (...) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84576       };
84577     }
84578   }
84579 }
84580
84581
84582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
84583   void * jresult ;
84584   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
84585
84586   {
84587     try {
84588       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
84589     } catch (std::out_of_range& e) {
84590       {
84591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84592       };
84593     } catch (std::exception& e) {
84594       {
84595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84596       };
84597     } catch (...) {
84598       {
84599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84600       };
84601     }
84602   }
84603   jresult = (void *)result;
84604   return jresult;
84605 }
84606
84607
84608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
84609   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
84610
84611   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
84612   {
84613     try {
84614       delete arg1;
84615     } catch (std::out_of_range& e) {
84616       {
84617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84618       };
84619     } catch (std::exception& e) {
84620       {
84621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84622       };
84623     } catch (...) {
84624       {
84625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84626       };
84627     }
84628   }
84629 }
84630
84631
84632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
84633   unsigned int jresult ;
84634   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84635   bool result;
84636
84637   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84638   {
84639     try {
84640       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);
84641     } catch (std::out_of_range& e) {
84642       {
84643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (std::exception& e) {
84646       {
84647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655   jresult = result;
84656   return jresult;
84657 }
84658
84659
84660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
84661   unsigned long jresult ;
84662   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84663   std::size_t result;
84664
84665   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84666   {
84667     try {
84668       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);
84669     } catch (std::out_of_range& e) {
84670       {
84671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (std::exception& e) {
84674       {
84675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (...) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84680       };
84681     }
84682   }
84683   jresult = (unsigned long)result;
84684   return jresult;
84685 }
84686
84687
84688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
84689   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84690   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84691
84692   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84693   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84694   {
84695     try {
84696       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84697     } catch (std::out_of_range& e) {
84698       {
84699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84700       };
84701     } catch (std::exception& e) {
84702       {
84703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84704       };
84705     } catch (...) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84708       };
84709     }
84710   }
84711 }
84712
84713
84714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
84715   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84716   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
84717
84718   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84719   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
84720   {
84721     try {
84722       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84723     } catch (std::out_of_range& e) {
84724       {
84725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84726       };
84727     } catch (std::exception& e) {
84728       {
84729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84730       };
84731     } catch (...) {
84732       {
84733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84734       };
84735     }
84736   }
84737 }
84738
84739
84740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
84741   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84742   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
84743
84744   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84745   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
84746   if (!arg2) {
84747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
84748     return ;
84749   }
84750   {
84751     try {
84752       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
84753     } catch (std::out_of_range& e) {
84754       {
84755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84756       };
84757     } catch (std::exception& e) {
84758       {
84759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84764       };
84765     }
84766   }
84767 }
84768
84769
84770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
84771   void * jresult ;
84772   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
84773
84774   {
84775     try {
84776       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
84797   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
84798
84799   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
84800   {
84801     try {
84802       delete arg1;
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84810       };
84811     } catch (...) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84814       };
84815     }
84816   }
84817 }
84818
84819
84820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
84821   unsigned int jresult ;
84822   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84823   bool result;
84824
84825   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84826   {
84827     try {
84828       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84829     } catch (std::out_of_range& e) {
84830       {
84831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84832       };
84833     } catch (std::exception& e) {
84834       {
84835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (...) {
84838       {
84839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84840       };
84841     }
84842   }
84843   jresult = result;
84844   return jresult;
84845 }
84846
84847
84848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
84849   unsigned long jresult ;
84850   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84851   std::size_t result;
84852
84853   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84854   {
84855     try {
84856       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
84857     } catch (std::out_of_range& e) {
84858       {
84859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (std::exception& e) {
84862       {
84863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871   jresult = (unsigned long)result;
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
84877   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84878   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84879
84880   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84881   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84882   {
84883     try {
84884       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
84885     } catch (std::out_of_range& e) {
84886       {
84887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84888       };
84889     } catch (std::exception& e) {
84890       {
84891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84896       };
84897     }
84898   }
84899 }
84900
84901
84902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
84903   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84904   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
84905
84906   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84907   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
84908   {
84909     try {
84910       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
84911     } catch (std::out_of_range& e) {
84912       {
84913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84914       };
84915     } catch (std::exception& e) {
84916       {
84917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84918       };
84919     } catch (...) {
84920       {
84921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84922       };
84923     }
84924   }
84925 }
84926
84927
84928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
84929   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84930   Dali::Vector2 *arg2 = 0 ;
84931
84932   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84933   arg2 = (Dali::Vector2 *)jarg2;
84934   if (!arg2) {
84935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84936     return ;
84937   }
84938   {
84939     try {
84940       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
84941     } catch (std::out_of_range& e) {
84942       {
84943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84944       };
84945     } catch (std::exception& e) {
84946       {
84947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84948       };
84949     } catch (...) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84952       };
84953     }
84954   }
84955 }
84956
84957
84958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
84959   void * jresult ;
84960   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
84961
84962   {
84963     try {
84964       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
84965     } catch (std::out_of_range& e) {
84966       {
84967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84968       };
84969     } catch (std::exception& e) {
84970       {
84971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84972       };
84973     } catch (...) {
84974       {
84975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84976       };
84977     }
84978   }
84979   jresult = (void *)result;
84980   return jresult;
84981 }
84982
84983
84984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
84985   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
84986
84987   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
84988   {
84989     try {
84990       delete arg1;
84991     } catch (std::out_of_range& e) {
84992       {
84993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84994       };
84995     } catch (std::exception& e) {
84996       {
84997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84998       };
84999     } catch (...) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85002       };
85003     }
85004   }
85005 }
85006
85007
85008
85009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
85010   unsigned int jresult ;
85011   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85012   bool result;
85013
85014   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85015   {
85016     try {
85017       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);
85018     } catch (std::out_of_range& e) {
85019       {
85020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85021       };
85022     } catch (std::exception& e) {
85023       {
85024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85025       };
85026     } catch (...) {
85027       {
85028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85029       };
85030     }
85031   }
85032   jresult = result;
85033   return jresult;
85034 }
85035
85036
85037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
85038   unsigned long jresult ;
85039   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85040   std::size_t result;
85041
85042   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85043   {
85044     try {
85045       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);
85046     } catch (std::out_of_range& e) {
85047       {
85048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85049       };
85050     } catch (std::exception& e) {
85051       {
85052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85053       };
85054     } catch (...) {
85055       {
85056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85057       };
85058     }
85059   }
85060   jresult = (unsigned long)result;
85061   return jresult;
85062 }
85063
85064
85065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
85066   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85067   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
85068
85069   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85070   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
85071   {
85072     try {
85073       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
85074     } catch (std::out_of_range& e) {
85075       {
85076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85077       };
85078     } catch (std::exception& e) {
85079       {
85080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85081       };
85082     } catch (...) {
85083       {
85084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85085       };
85086     }
85087   }
85088 }
85089
85090
85091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
85092   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85093   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
85094
85095   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85096   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
85097   {
85098     try {
85099       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
85100     } catch (std::out_of_range& e) {
85101       {
85102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85103       };
85104     } catch (std::exception& e) {
85105       {
85106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85107       };
85108     } catch (...) {
85109       {
85110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85111       };
85112     }
85113   }
85114 }
85115
85116
85117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
85118   unsigned int jresult ;
85119   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85120   Dali::Toolkit::Control arg2 ;
85121   Dali::KeyEvent *arg3 = 0 ;
85122   Dali::Toolkit::Control *argp2 ;
85123   bool result;
85124
85125   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85126   argp2 = (Dali::Toolkit::Control *)jarg2;
85127   if (!argp2) {
85128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85129     return 0;
85130   }
85131   arg2 = *argp2;
85132   arg3 = (Dali::KeyEvent *)jarg3;
85133   if (!arg3) {
85134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
85135     return 0;
85136   }
85137   {
85138     try {
85139       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);
85140     } catch (std::out_of_range& e) {
85141       {
85142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85143       };
85144     } catch (std::exception& e) {
85145       {
85146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85147       };
85148     } catch (...) {
85149       {
85150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85151       };
85152     }
85153   }
85154   jresult = result;
85155   return jresult;
85156 }
85157
85158
85159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
85160   void * jresult ;
85161   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
85162
85163   {
85164     try {
85165       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
85166     } catch (std::out_of_range& e) {
85167       {
85168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85169       };
85170     } catch (std::exception& e) {
85171       {
85172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85173       };
85174     } catch (...) {
85175       {
85176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85177       };
85178     }
85179   }
85180   jresult = (void *)result;
85181   return jresult;
85182 }
85183
85184
85185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
85186   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
85187
85188   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
85189   {
85190     try {
85191       delete arg1;
85192     } catch (std::out_of_range& e) {
85193       {
85194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85195       };
85196     } catch (std::exception& e) {
85197       {
85198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85199       };
85200     } catch (...) {
85201       {
85202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85203       };
85204     }
85205   }
85206 }
85207
85208
85209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
85210   unsigned int jresult ;
85211   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85212   bool result;
85213
85214   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85215   {
85216     try {
85217       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85218     } catch (std::out_of_range& e) {
85219       {
85220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85221       };
85222     } catch (std::exception& e) {
85223       {
85224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85225       };
85226     } catch (...) {
85227       {
85228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85229       };
85230     }
85231   }
85232   jresult = result;
85233   return jresult;
85234 }
85235
85236
85237 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
85238   unsigned long jresult ;
85239   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85240   std::size_t result;
85241
85242   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85243   {
85244     try {
85245       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85257       };
85258     }
85259   }
85260   jresult = (unsigned long)result;
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
85266   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85267   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85268
85269   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85270   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85271   {
85272     try {
85273       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
85274     } catch (std::out_of_range& e) {
85275       {
85276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85277       };
85278     } catch (std::exception& e) {
85279       {
85280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85281       };
85282     } catch (...) {
85283       {
85284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85285       };
85286     }
85287   }
85288 }
85289
85290
85291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
85292   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85293   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
85294
85295   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85296   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
85297   {
85298     try {
85299       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
85300     } catch (std::out_of_range& e) {
85301       {
85302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85303       };
85304     } catch (std::exception& e) {
85305       {
85306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85307       };
85308     } catch (...) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85311       };
85312     }
85313   }
85314 }
85315
85316
85317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
85318   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85319   Dali::Toolkit::Control arg2 ;
85320   Dali::Toolkit::Control *argp2 ;
85321
85322   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85323   argp2 = (Dali::Toolkit::Control *)jarg2;
85324   if (!argp2) {
85325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85326     return ;
85327   }
85328   arg2 = *argp2;
85329   {
85330     try {
85331       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
85332     } catch (std::out_of_range& e) {
85333       {
85334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85335       };
85336     } catch (std::exception& e) {
85337       {
85338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (...) {
85341       {
85342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85343       };
85344     }
85345   }
85346 }
85347
85348
85349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
85350   void * jresult ;
85351   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
85352
85353   {
85354     try {
85355       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
85356     } catch (std::out_of_range& e) {
85357       {
85358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85359       };
85360     } catch (std::exception& e) {
85361       {
85362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85363       };
85364     } catch (...) {
85365       {
85366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85367       };
85368     }
85369   }
85370   jresult = (void *)result;
85371   return jresult;
85372 }
85373
85374
85375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
85376   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
85377
85378   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
85379   {
85380     try {
85381       delete arg1;
85382     } catch (std::out_of_range& e) {
85383       {
85384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85385       };
85386     } catch (std::exception& e) {
85387       {
85388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85389       };
85390     } catch (...) {
85391       {
85392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85393       };
85394     }
85395   }
85396 }
85397
85398
85399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
85400   unsigned int jresult ;
85401   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85402   bool result;
85403
85404   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85405   {
85406     try {
85407       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85408     } catch (std::out_of_range& e) {
85409       {
85410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85411       };
85412     } catch (std::exception& e) {
85413       {
85414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85415       };
85416     } catch (...) {
85417       {
85418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85419       };
85420     }
85421   }
85422   jresult = result;
85423   return jresult;
85424 }
85425
85426
85427 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
85428   unsigned long jresult ;
85429   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85430   std::size_t result;
85431
85432   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85433   {
85434     try {
85435       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
85436     } catch (std::out_of_range& e) {
85437       {
85438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85439       };
85440     } catch (std::exception& e) {
85441       {
85442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85443       };
85444     } catch (...) {
85445       {
85446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85447       };
85448     }
85449   }
85450   jresult = (unsigned long)result;
85451   return jresult;
85452 }
85453
85454
85455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
85456   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85457   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85458
85459   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85460   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85461   {
85462     try {
85463       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
85464     } catch (std::out_of_range& e) {
85465       {
85466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85467       };
85468     } catch (std::exception& e) {
85469       {
85470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85471       };
85472     } catch (...) {
85473       {
85474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85475       };
85476     }
85477   }
85478 }
85479
85480
85481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
85482   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85483   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
85484
85485   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85486   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
85487   {
85488     try {
85489       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
85490     } catch (std::out_of_range& e) {
85491       {
85492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85493       };
85494     } catch (std::exception& e) {
85495       {
85496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85497       };
85498     } catch (...) {
85499       {
85500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85501       };
85502     }
85503   }
85504 }
85505
85506
85507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
85508   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85509   Dali::Toolkit::VideoView *arg2 = 0 ;
85510
85511   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85512   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85513   if (!arg2) {
85514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
85515     return ;
85516   }
85517   {
85518     try {
85519       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
85520     } catch (std::out_of_range& e) {
85521       {
85522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85523       };
85524     } catch (std::exception& e) {
85525       {
85526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85527       };
85528     } catch (...) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85531       };
85532     }
85533   }
85534 }
85535
85536
85537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
85538   void * jresult ;
85539   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
85540
85541   {
85542     try {
85543       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
85544     } catch (std::out_of_range& e) {
85545       {
85546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (std::exception& e) {
85549       {
85550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85555       };
85556     }
85557   }
85558   jresult = (void *)result;
85559   return jresult;
85560 }
85561
85562
85563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
85564   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
85565
85566   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
85567   {
85568     try {
85569       delete arg1;
85570     } catch (std::out_of_range& e) {
85571       {
85572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85573       };
85574     } catch (std::exception& e) {
85575       {
85576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85577       };
85578     } catch (...) {
85579       {
85580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85581       };
85582     }
85583   }
85584 }
85585
85586
85587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
85588   unsigned int jresult ;
85589   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85590   bool result;
85591
85592   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85593   {
85594     try {
85595       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85596     } catch (std::out_of_range& e) {
85597       {
85598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85599       };
85600     } catch (std::exception& e) {
85601       {
85602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85603       };
85604     } catch (...) {
85605       {
85606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85607       };
85608     }
85609   }
85610   jresult = result;
85611   return jresult;
85612 }
85613
85614
85615 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
85616   unsigned long jresult ;
85617   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85618   std::size_t result;
85619
85620   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85621   {
85622     try {
85623       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
85624     } catch (std::out_of_range& e) {
85625       {
85626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85627       };
85628     } catch (std::exception& e) {
85629       {
85630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85631       };
85632     } catch (...) {
85633       {
85634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85635       };
85636     }
85637   }
85638   jresult = (unsigned long)result;
85639   return jresult;
85640 }
85641
85642
85643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
85644   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85645   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85646
85647   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85648   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85649   {
85650     try {
85651       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85659       };
85660     } catch (...) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85663       };
85664     }
85665   }
85666 }
85667
85668
85669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85670   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85671   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
85672
85673   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85674   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
85675   {
85676     try {
85677       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
85678     } catch (std::out_of_range& e) {
85679       {
85680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85681       };
85682     } catch (std::exception& e) {
85683       {
85684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85685       };
85686     } catch (...) {
85687       {
85688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85689       };
85690     }
85691   }
85692 }
85693
85694
85695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
85696   unsigned int jresult ;
85697   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85698   Dali::Toolkit::Slider arg2 ;
85699   float arg3 ;
85700   Dali::Toolkit::Slider *argp2 ;
85701   bool result;
85702
85703   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85704   argp2 = (Dali::Toolkit::Slider *)jarg2;
85705   if (!argp2) {
85706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85707     return 0;
85708   }
85709   arg2 = *argp2;
85710   arg3 = (float)jarg3;
85711   {
85712     try {
85713       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
85714     } catch (std::out_of_range& e) {
85715       {
85716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85717       };
85718     } catch (std::exception& e) {
85719       {
85720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85721       };
85722     } catch (...) {
85723       {
85724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85725       };
85726     }
85727   }
85728   jresult = result;
85729   return jresult;
85730 }
85731
85732
85733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
85734   void * jresult ;
85735   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
85736
85737   {
85738     try {
85739       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
85740     } catch (std::out_of_range& e) {
85741       {
85742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85743       };
85744     } catch (std::exception& e) {
85745       {
85746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85747       };
85748     } catch (...) {
85749       {
85750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85751       };
85752     }
85753   }
85754   jresult = (void *)result;
85755   return jresult;
85756 }
85757
85758
85759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
85760   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
85761
85762   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
85763   {
85764     try {
85765       delete arg1;
85766     } catch (std::out_of_range& e) {
85767       {
85768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85769       };
85770     } catch (std::exception& e) {
85771       {
85772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85773       };
85774     } catch (...) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85777       };
85778     }
85779   }
85780 }
85781
85782
85783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
85784   unsigned int jresult ;
85785   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85786   bool result;
85787
85788   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85789   {
85790     try {
85791       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85792     } catch (std::out_of_range& e) {
85793       {
85794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85795       };
85796     } catch (std::exception& e) {
85797       {
85798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85799       };
85800     } catch (...) {
85801       {
85802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85803       };
85804     }
85805   }
85806   jresult = result;
85807   return jresult;
85808 }
85809
85810
85811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
85812   unsigned long jresult ;
85813   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85814   std::size_t result;
85815
85816   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85817   {
85818     try {
85819       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
85820     } catch (std::out_of_range& e) {
85821       {
85822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85823       };
85824     } catch (std::exception& e) {
85825       {
85826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85827       };
85828     } catch (...) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85831       };
85832     }
85833   }
85834   jresult = (unsigned long)result;
85835   return jresult;
85836 }
85837
85838
85839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
85840   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85841   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85842
85843   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85844   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85845   {
85846     try {
85847       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85855       };
85856     } catch (...) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85859       };
85860     }
85861   }
85862 }
85863
85864
85865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
85866   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85867   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
85868
85869   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85870   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
85871   {
85872     try {
85873       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
85874     } catch (std::out_of_range& e) {
85875       {
85876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85877       };
85878     } catch (std::exception& e) {
85879       {
85880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85881       };
85882     } catch (...) {
85883       {
85884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85885       };
85886     }
85887   }
85888 }
85889
85890
85891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85892   unsigned int jresult ;
85893   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85894   Dali::Toolkit::Slider arg2 ;
85895   int arg3 ;
85896   Dali::Toolkit::Slider *argp2 ;
85897   bool result;
85898
85899   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85900   argp2 = (Dali::Toolkit::Slider *)jarg2;
85901   if (!argp2) {
85902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
85903     return 0;
85904   }
85905   arg2 = *argp2;
85906   arg3 = (int)jarg3;
85907   {
85908     try {
85909       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
85910     } catch (std::out_of_range& e) {
85911       {
85912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85913       };
85914     } catch (std::exception& e) {
85915       {
85916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (...) {
85919       {
85920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85921       };
85922     }
85923   }
85924   jresult = result;
85925   return jresult;
85926 }
85927
85928
85929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
85930   void * jresult ;
85931   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
85932
85933   {
85934     try {
85935       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
85936     } catch (std::out_of_range& e) {
85937       {
85938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (std::exception& e) {
85941       {
85942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85943       };
85944     } catch (...) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85947       };
85948     }
85949   }
85950   jresult = (void *)result;
85951   return jresult;
85952 }
85953
85954
85955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
85956   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
85957
85958   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
85959   {
85960     try {
85961       delete arg1;
85962     } catch (std::out_of_range& e) {
85963       {
85964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85965       };
85966     } catch (std::exception& e) {
85967       {
85968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85969       };
85970     } catch (...) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85973       };
85974     }
85975   }
85976 }
85977
85978
85979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
85980   void * jresult ;
85981   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
85982
85983   {
85984     try {
85985       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
85986     } catch (std::out_of_range& e) {
85987       {
85988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (std::exception& e) {
85991       {
85992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85993       };
85994     } catch (...) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85997       };
85998     }
85999   }
86000   jresult = (void *)result;
86001   return jresult;
86002 }
86003
86004
86005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
86006   void * jresult ;
86007   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
86008   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86009
86010   arg1 = (Dali::Toolkit::Ruler *)jarg1;
86011   {
86012     try {
86013       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
86014     } catch (std::out_of_range& e) {
86015       {
86016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86017       };
86018     } catch (std::exception& e) {
86019       {
86020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86021       };
86022     } catch (...) {
86023       {
86024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86025       };
86026     }
86027   }
86028   jresult = (void *)result;
86029   return jresult;
86030 }
86031
86032
86033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
86034   void * jresult ;
86035   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
86036   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86037
86038   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86039   if (!arg1) {
86040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86041     return 0;
86042   }
86043   {
86044     try {
86045       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
86046     } catch (std::out_of_range& e) {
86047       {
86048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86049       };
86050     } catch (std::exception& e) {
86051       {
86052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86053       };
86054     } catch (...) {
86055       {
86056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86057       };
86058     }
86059   }
86060   jresult = (void *)result;
86061   return jresult;
86062 }
86063
86064
86065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
86066   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86067
86068   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86069   {
86070     try {
86071       delete arg1;
86072     } catch (std::out_of_range& e) {
86073       {
86074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86075       };
86076     } catch (std::exception& e) {
86077       {
86078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86079       };
86080     } catch (...) {
86081       {
86082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86083       };
86084     }
86085   }
86086 }
86087
86088
86089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
86090   void * jresult ;
86091   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86092   Dali::Toolkit::Ruler *result = 0 ;
86093
86094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86095   {
86096     try {
86097       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
86098     } catch (std::out_of_range& e) {
86099       {
86100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86101       };
86102     } catch (std::exception& e) {
86103       {
86104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86105       };
86106     } catch (...) {
86107       {
86108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86109       };
86110     }
86111   }
86112   jresult = (void *)result;
86113   return jresult;
86114 }
86115
86116
86117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
86118   void * jresult ;
86119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86120   Dali::Toolkit::Ruler *result = 0 ;
86121
86122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86123   {
86124     try {
86125       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
86126     } catch (std::out_of_range& e) {
86127       {
86128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86129       };
86130     } catch (std::exception& e) {
86131       {
86132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (...) {
86135       {
86136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86137       };
86138     }
86139   }
86140   jresult = (void *)result;
86141   return jresult;
86142 }
86143
86144
86145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
86146   void * jresult ;
86147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86148   Dali::Toolkit::Ruler *result = 0 ;
86149
86150   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86151   {
86152     try {
86153       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
86154     } catch (std::out_of_range& e) {
86155       {
86156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86157       };
86158     } catch (std::exception& e) {
86159       {
86160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86161       };
86162     } catch (...) {
86163       {
86164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86165       };
86166     }
86167   }
86168   jresult = (void *)result;
86169   return jresult;
86170 }
86171
86172
86173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
86174   void * jresult ;
86175   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
86177   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86178
86179   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86180   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
86181   if (!arg2) {
86182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
86183     return 0;
86184   }
86185   {
86186     try {
86187       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
86188     } catch (std::out_of_range& e) {
86189       {
86190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86191       };
86192     } catch (std::exception& e) {
86193       {
86194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86195       };
86196     } catch (...) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86199       };
86200     }
86201   }
86202   jresult = (void *)result;
86203   return jresult;
86204 }
86205
86206
86207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
86208   void * jresult ;
86209   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86210   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
86212
86213   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86214   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86215   {
86216     try {
86217       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86229       };
86230     }
86231   }
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
86238   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86239
86240   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86241   {
86242     try {
86243       (arg1)->Reset();
86244     } catch (std::out_of_range& e) {
86245       {
86246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86247       };
86248     } catch (std::exception& e) {
86249       {
86250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86251       };
86252     } catch (...) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86255       };
86256     }
86257   }
86258 }
86259
86260
86261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
86262   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86263   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
86264
86265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86266   arg2 = (Dali::Toolkit::Ruler *)jarg2;
86267   {
86268     try {
86269       (arg1)->Reset(arg2);
86270     } catch (std::out_of_range& e) {
86271       {
86272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86273       };
86274     } catch (std::exception& e) {
86275       {
86276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86277       };
86278     } catch (...) {
86279       {
86280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86281       };
86282     }
86283   }
86284 }
86285
86286
86287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
86288   void * jresult ;
86289   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86290   Dali::Toolkit::Ruler *result = 0 ;
86291
86292   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86293   {
86294     try {
86295       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
86296     } catch (std::out_of_range& e) {
86297       {
86298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86299       };
86300     } catch (std::exception& e) {
86301       {
86302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86303       };
86304     } catch (...) {
86305       {
86306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86307       };
86308     }
86309   }
86310   jresult = (void *)result;
86311   return jresult;
86312 }
86313
86314
86315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
86316   float jresult ;
86317   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86318   float arg2 ;
86319   float arg3 ;
86320   float result;
86321
86322   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86323   arg2 = (float)jarg2;
86324   arg3 = (float)jarg3;
86325   {
86326     try {
86327       result = (float)(*arg1)->Snap(arg2,arg3);
86328     } catch (std::out_of_range& e) {
86329       {
86330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (std::exception& e) {
86333       {
86334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86335       };
86336     } catch (...) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86339       };
86340     }
86341   }
86342   jresult = result;
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
86348   float jresult ;
86349   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86350   float arg2 ;
86351   float result;
86352
86353   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86354   arg2 = (float)jarg2;
86355   {
86356     try {
86357       result = (float)(*arg1)->Snap(arg2);
86358     } catch (std::out_of_range& e) {
86359       {
86360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (std::exception& e) {
86363       {
86364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372   jresult = result;
86373   return jresult;
86374 }
86375
86376
86377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
86378   float jresult ;
86379   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86380   unsigned int arg2 ;
86381   unsigned int *arg3 = 0 ;
86382   bool arg4 ;
86383   float result;
86384
86385   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86386   arg2 = (unsigned int)jarg2;
86387   arg3 = (unsigned int *)jarg3;
86388   arg4 = jarg4 ? true : false;
86389   {
86390     try {
86391       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
86392     } catch (std::out_of_range& e) {
86393       {
86394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (std::exception& e) {
86397       {
86398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406   jresult = result;
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
86412   unsigned int jresult ;
86413   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86414   float arg2 ;
86415   bool arg3 ;
86416   unsigned int result;
86417
86418   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86419   arg2 = (float)jarg2;
86420   arg3 = jarg3 ? true : false;
86421   {
86422     try {
86423       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
86424     } catch (std::out_of_range& e) {
86425       {
86426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86427       };
86428     } catch (std::exception& e) {
86429       {
86430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86431       };
86432     } catch (...) {
86433       {
86434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86435       };
86436     }
86437   }
86438   jresult = result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
86444   unsigned int jresult ;
86445   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86446   unsigned int result;
86447
86448   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86449   {
86450     try {
86451       result = (unsigned int)(*arg1)->GetTotalPages();
86452     } catch (std::out_of_range& e) {
86453       {
86454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86455       };
86456     } catch (std::exception& e) {
86457       {
86458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86459       };
86460     } catch (...) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86463       };
86464     }
86465   }
86466   jresult = result;
86467   return jresult;
86468 }
86469
86470
86471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
86472   int jresult ;
86473   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86474   Dali::Toolkit::Ruler::RulerType result;
86475
86476   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86477   {
86478     try {
86479       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
86480     } catch (std::out_of_range& e) {
86481       {
86482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86483       };
86484     } catch (std::exception& e) {
86485       {
86486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86487       };
86488     } catch (...) {
86489       {
86490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86491       };
86492     }
86493   }
86494   jresult = (int)result;
86495   return jresult;
86496 }
86497
86498
86499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
86500   unsigned int jresult ;
86501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86502   bool result;
86503
86504   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86505   {
86506     try {
86507       result = (bool)(*arg1)->IsEnabled();
86508     } catch (std::out_of_range& e) {
86509       {
86510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86511       };
86512     } catch (std::exception& e) {
86513       {
86514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86519       };
86520     }
86521   }
86522   jresult = result;
86523   return jresult;
86524 }
86525
86526
86527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
86528   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86529
86530   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86531   {
86532     try {
86533       (*arg1)->Enable();
86534     } catch (std::out_of_range& e) {
86535       {
86536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86537       };
86538     } catch (std::exception& e) {
86539       {
86540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86541       };
86542     } catch (...) {
86543       {
86544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86545       };
86546     }
86547   }
86548 }
86549
86550
86551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
86552   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86553
86554   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86555   {
86556     try {
86557       (*arg1)->Disable();
86558     } catch (std::out_of_range& e) {
86559       {
86560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86561       };
86562     } catch (std::exception& e) {
86563       {
86564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86565       };
86566     } catch (...) {
86567       {
86568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86569       };
86570     }
86571   }
86572 }
86573
86574
86575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
86576   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86577   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
86578   Dali::Toolkit::RulerDomain *argp2 ;
86579
86580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86581   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
86582   if (!argp2) {
86583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
86584     return ;
86585   }
86586   arg2 = *argp2;
86587   {
86588     try {
86589       (*arg1)->SetDomain(arg2);
86590     } catch (std::out_of_range& e) {
86591       {
86592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86593       };
86594     } catch (std::exception& e) {
86595       {
86596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86597       };
86598     } catch (...) {
86599       {
86600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86601       };
86602     }
86603   }
86604 }
86605
86606
86607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
86608   void * jresult ;
86609   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86610   Dali::Toolkit::RulerDomain *result = 0 ;
86611
86612   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86613   {
86614     try {
86615       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
86616     } catch (std::out_of_range& e) {
86617       {
86618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86619       };
86620     } catch (std::exception& e) {
86621       {
86622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86623       };
86624     } catch (...) {
86625       {
86626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86627       };
86628     }
86629   }
86630   jresult = (void *)result;
86631   return jresult;
86632 }
86633
86634
86635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
86636   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86637
86638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86639   {
86640     try {
86641       (*arg1)->DisableDomain();
86642     } catch (std::out_of_range& e) {
86643       {
86644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86645       };
86646     } catch (std::exception& e) {
86647       {
86648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86649       };
86650     } catch (...) {
86651       {
86652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86653       };
86654     }
86655   }
86656 }
86657
86658
86659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
86660   float jresult ;
86661   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86662   float arg2 ;
86663   float arg3 ;
86664   float arg4 ;
86665   float result;
86666
86667   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86668   arg2 = (float)jarg2;
86669   arg3 = (float)jarg3;
86670   arg4 = (float)jarg4;
86671   {
86672     try {
86673       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
86674     } catch (std::out_of_range& e) {
86675       {
86676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86677       };
86678     } catch (std::exception& e) {
86679       {
86680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86681       };
86682     } catch (...) {
86683       {
86684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86685       };
86686     }
86687   }
86688   jresult = result;
86689   return jresult;
86690 }
86691
86692
86693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
86694   float jresult ;
86695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86696   float arg2 ;
86697   float arg3 ;
86698   float result;
86699
86700   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86701   arg2 = (float)jarg2;
86702   arg3 = (float)jarg3;
86703   {
86704     try {
86705       result = (float)(*arg1)->Clamp(arg2,arg3);
86706     } catch (std::out_of_range& e) {
86707       {
86708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (std::exception& e) {
86711       {
86712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (...) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86717       };
86718     }
86719   }
86720   jresult = result;
86721   return jresult;
86722 }
86723
86724
86725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
86726   float jresult ;
86727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86728   float arg2 ;
86729   float result;
86730
86731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86732   arg2 = (float)jarg2;
86733   {
86734     try {
86735       result = (float)(*arg1)->Clamp(arg2);
86736     } catch (std::out_of_range& e) {
86737       {
86738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86739       };
86740     } catch (std::exception& e) {
86741       {
86742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86743       };
86744     } catch (...) {
86745       {
86746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86747       };
86748     }
86749   }
86750   jresult = result;
86751   return jresult;
86752 }
86753
86754
86755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
86756   float jresult ;
86757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86758   float arg2 ;
86759   float arg3 ;
86760   float arg4 ;
86761   Dali::Toolkit::ClampState *arg5 = 0 ;
86762   float result;
86763
86764   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86765   arg2 = (float)jarg2;
86766   arg3 = (float)jarg3;
86767   arg4 = (float)jarg4;
86768   arg5 = (Dali::Toolkit::ClampState *)jarg5;
86769   if (!arg5) {
86770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86771     return 0;
86772   }
86773   {
86774     try {
86775       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
86776     } catch (std::out_of_range& e) {
86777       {
86778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (std::exception& e) {
86781       {
86782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86783       };
86784     } catch (...) {
86785       {
86786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86787       };
86788     }
86789   }
86790   jresult = result;
86791   return jresult;
86792 }
86793
86794
86795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
86796   float jresult ;
86797   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86798   float arg2 ;
86799   float arg3 ;
86800   float arg4 ;
86801   float arg5 ;
86802   float result;
86803
86804   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86805   arg2 = (float)jarg2;
86806   arg3 = (float)jarg3;
86807   arg4 = (float)jarg4;
86808   arg5 = (float)jarg5;
86809   {
86810     try {
86811       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
86812     } catch (std::out_of_range& e) {
86813       {
86814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86815       };
86816     } catch (std::exception& e) {
86817       {
86818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (...) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86823       };
86824     }
86825   }
86826   jresult = result;
86827   return jresult;
86828 }
86829
86830
86831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
86832   float jresult ;
86833   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86834   float arg2 ;
86835   float arg3 ;
86836   float arg4 ;
86837   float result;
86838
86839   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86840   arg2 = (float)jarg2;
86841   arg3 = (float)jarg3;
86842   arg4 = (float)jarg4;
86843   {
86844     try {
86845       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
86846     } catch (std::out_of_range& e) {
86847       {
86848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86849       };
86850     } catch (std::exception& e) {
86851       {
86852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (...) {
86855       {
86856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86857       };
86858     }
86859   }
86860   jresult = result;
86861   return jresult;
86862 }
86863
86864
86865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
86866   float jresult ;
86867   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86868   float arg2 ;
86869   float arg3 ;
86870   float result;
86871
86872   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86873   arg2 = (float)jarg2;
86874   arg3 = (float)jarg3;
86875   {
86876     try {
86877       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
86878     } catch (std::out_of_range& e) {
86879       {
86880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86881       };
86882     } catch (std::exception& e) {
86883       {
86884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86885       };
86886     } catch (...) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86889       };
86890     }
86891   }
86892   jresult = result;
86893   return jresult;
86894 }
86895
86896
86897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
86898   float jresult ;
86899   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86900   float arg2 ;
86901   float result;
86902
86903   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86904   arg2 = (float)jarg2;
86905   {
86906     try {
86907       result = (float)(*arg1)->SnapAndClamp(arg2);
86908     } catch (std::out_of_range& e) {
86909       {
86910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (std::exception& e) {
86913       {
86914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86919       };
86920     }
86921   }
86922   jresult = result;
86923   return jresult;
86924 }
86925
86926
86927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
86928   float jresult ;
86929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86930   float arg2 ;
86931   float arg3 ;
86932   float arg4 ;
86933   float arg5 ;
86934   Dali::Toolkit::ClampState *arg6 = 0 ;
86935   float result;
86936
86937   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86938   arg2 = (float)jarg2;
86939   arg3 = (float)jarg3;
86940   arg4 = (float)jarg4;
86941   arg5 = (float)jarg5;
86942   arg6 = (Dali::Toolkit::ClampState *)jarg6;
86943   if (!arg6) {
86944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
86945     return 0;
86946   }
86947   {
86948     try {
86949       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
86950     } catch (std::out_of_range& e) {
86951       {
86952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86953       };
86954     } catch (std::exception& e) {
86955       {
86956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86957       };
86958     } catch (...) {
86959       {
86960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86961       };
86962     }
86963   }
86964   jresult = result;
86965   return jresult;
86966 }
86967
86968
86969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
86970   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86971
86972   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86973   {
86974     try {
86975       (*arg1)->Reference();
86976     } catch (std::out_of_range& e) {
86977       {
86978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86979       };
86980     } catch (std::exception& e) {
86981       {
86982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86983       };
86984     } catch (...) {
86985       {
86986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86987       };
86988     }
86989   }
86990 }
86991
86992
86993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
86994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
86995
86996   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
86997   {
86998     try {
86999       (*arg1)->Unreference();
87000     } catch (std::out_of_range& e) {
87001       {
87002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87003       };
87004     } catch (std::exception& e) {
87005       {
87006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87007       };
87008     } catch (...) {
87009       {
87010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87011       };
87012     }
87013   }
87014 }
87015
87016
87017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
87018   int jresult ;
87019   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
87020   int result;
87021
87022   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
87023   {
87024     try {
87025       result = (int)(*arg1)->ReferenceCount();
87026     } catch (std::out_of_range& e) {
87027       {
87028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87029       };
87030     } catch (std::exception& e) {
87031       {
87032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87033       };
87034     } catch (...) {
87035       {
87036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87037       };
87038     }
87039   }
87040   jresult = result;
87041   return jresult;
87042 }
87043
87044
87045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
87046   unsigned int jresult ;
87047   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87048   bool result;
87049
87050   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87051   {
87052     try {
87053       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87054     } catch (std::out_of_range& e) {
87055       {
87056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87057       };
87058     } catch (std::exception& e) {
87059       {
87060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87061       };
87062     } catch (...) {
87063       {
87064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87065       };
87066     }
87067   }
87068   jresult = result;
87069   return jresult;
87070 }
87071
87072
87073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
87074   unsigned long jresult ;
87075   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87076   std::size_t result;
87077
87078   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87079   {
87080     try {
87081       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87082     } catch (std::out_of_range& e) {
87083       {
87084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87085       };
87086     } catch (std::exception& e) {
87087       {
87088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87089       };
87090     } catch (...) {
87091       {
87092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87093       };
87094     }
87095   }
87096   jresult = (unsigned long)result;
87097   return jresult;
87098 }
87099
87100
87101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
87102   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87103   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87104
87105   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87106   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87107   {
87108     try {
87109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
87110     } catch (std::out_of_range& e) {
87111       {
87112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87113       };
87114     } catch (std::exception& e) {
87115       {
87116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87117       };
87118     } catch (...) {
87119       {
87120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87121       };
87122     }
87123   }
87124 }
87125
87126
87127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
87128   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87129   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87130
87131   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87132   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87133   {
87134     try {
87135       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
87136     } catch (std::out_of_range& e) {
87137       {
87138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87139       };
87140     } catch (std::exception& e) {
87141       {
87142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87143       };
87144     } catch (...) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87147       };
87148     }
87149   }
87150 }
87151
87152
87153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
87154   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87155   Dali::Toolkit::Control arg2 ;
87156   Dali::Toolkit::Control *argp2 ;
87157
87158   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87159   argp2 = (Dali::Toolkit::Control *)jarg2;
87160   if (!argp2) {
87161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87162     return ;
87163   }
87164   arg2 = *argp2;
87165   {
87166     try {
87167       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87168     } catch (std::out_of_range& e) {
87169       {
87170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87171       };
87172     } catch (std::exception& e) {
87173       {
87174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87175       };
87176     } catch (...) {
87177       {
87178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87179       };
87180     }
87181   }
87182 }
87183
87184
87185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
87186   void * jresult ;
87187   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87188
87189   {
87190     try {
87191       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87192     } catch (std::out_of_range& e) {
87193       {
87194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87195       };
87196     } catch (std::exception& e) {
87197       {
87198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87199       };
87200     } catch (...) {
87201       {
87202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87203       };
87204     }
87205   }
87206   jresult = (void *)result;
87207   return jresult;
87208 }
87209
87210
87211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
87212   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87213
87214   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87215   {
87216     try {
87217       delete arg1;
87218     } catch (std::out_of_range& e) {
87219       {
87220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87221       };
87222     } catch (std::exception& e) {
87223       {
87224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87225       };
87226     } catch (...) {
87227       {
87228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87229       };
87230     }
87231   }
87232 }
87233
87234 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
87235   Dali::RefObject *result = NULL;
87236
87237   if (arg1)
87238   {
87239     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
87240   }
87241   return result;
87242 }
87243
87244 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
87245     return (Dali::RefObject *)jarg1;
87246 }
87247
87248 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
87249     return (Dali::SignalObserver *)jarg1;
87250 }
87251
87252 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
87253     return (Dali::ConnectionTrackerInterface *)jarg1;
87254 }
87255
87256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
87257     return (Dali::BaseHandle *)jarg1;
87258 }
87259
87260 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
87261     return (Dali::BaseHandle *)jarg1;
87262 }
87263
87264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
87265     return (Dali::BaseHandle *)jarg1;
87266 }
87267
87268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
87269     return (Dali::BaseHandle *)jarg1;
87270 }
87271
87272 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
87273     return (Dali::BaseHandle *)jarg1;
87274 }
87275
87276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
87277     return (Dali::BaseHandle *)jarg1;
87278 }
87279
87280 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
87281     return (Dali::BaseHandle *)jarg1;
87282 }
87283
87284 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
87285     return (Dali::BaseHandle *)jarg1;
87286 }
87287
87288 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
87289     return (Dali::BaseHandle *)jarg1;
87290 }
87291
87292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
87293     return (Dali::BaseHandle *)jarg1;
87294 }
87295
87296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
87297     return (Dali::BaseHandle *)jarg1;
87298 }
87299
87300 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
87301     return (Dali::BaseHandle *)jarg1;
87302 }
87303
87304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
87305     return (Dali::BaseHandle *)jarg1;
87306 }
87307
87308 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
87309     return (Dali::Handle *)jarg1;
87310 }
87311
87312 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
87313     return (Dali::Handle *)jarg1;
87314 }
87315
87316 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
87317     return (Dali::BaseHandle *)jarg1;
87318 }
87319
87320 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
87321     return (Dali::BaseHandle *)jarg1;
87322 }
87323
87324 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
87325     return (Dali::Handle *)jarg1;
87326 }
87327
87328 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
87329     return (Dali::BaseHandle *)jarg1;
87330 }
87331
87332 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
87333     return (Dali::Handle *)jarg1;
87334 }
87335
87336 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
87337     return (Dali::GestureDetector *)jarg1;
87338 }
87339
87340 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
87341     return (Dali::Gesture *)jarg1;
87342 }
87343
87344 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
87345     return (Dali::Handle *)jarg1;
87346 }
87347
87348 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
87349     return (Dali::Actor *)jarg1;
87350 }
87351
87352 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
87353     return (Dali::BaseHandle *)jarg1;
87354 }
87355
87356 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
87357     return (Dali::RefObject *)jarg1;
87358 }
87359
87360 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
87361     return (Dali::Actor *)jarg1;
87362 }
87363
87364 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
87365     return (Dali::GestureDetector *)jarg1;
87366 }
87367
87368 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
87369     return (Dali::Gesture *)jarg1;
87370 }
87371
87372 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
87373     return (Dali::GestureDetector *)jarg1;
87374 }
87375
87376 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
87377     return (Dali::Gesture *)jarg1;
87378 }
87379
87380 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
87381     return (Dali::GestureDetector *)jarg1;
87382 }
87383
87384 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
87385     return (Dali::Gesture *)jarg1;
87386 }
87387
87388 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
87389     return (Dali::BaseHandle *)jarg1;
87390 }
87391
87392 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
87393     return (Dali::Handle *)jarg1;
87394 }
87395
87396 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
87397     return (Dali::Handle *)jarg1;
87398 }
87399
87400 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
87401     return (Dali::Handle *)jarg1;
87402 }
87403
87404 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
87405     return (Dali::Image *)jarg1;
87406 }
87407
87408 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
87409     return (Dali::Image *)jarg1;
87410 }
87411
87412 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
87413     return (Dali::Image *)jarg1;
87414 }
87415
87416 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
87417     return (Dali::RefObject *)jarg1;
87418 }
87419
87420 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
87421     return (Dali::Image *)jarg1;
87422 }
87423
87424 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
87425     return (Dali::Image *)jarg1;
87426 }
87427
87428 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
87429     return (Dali::ResourceImage *)jarg1;
87430 }
87431
87432 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
87433     return (Dali::Actor *)jarg1;
87434 }
87435
87436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
87437     return (Dali::BaseHandle *)jarg1;
87438 }
87439
87440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
87441     return (Dali::BaseHandle *)jarg1;
87442 }
87443
87444
87445 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
87446     return (Dali::BaseHandle *)jarg1;
87447 }
87448
87449 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
87450     return (Dali::BaseHandle *)jarg1;
87451 }
87452
87453 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
87454     return (Dali::CustomActorImpl *)jarg1;
87455 }
87456
87457 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
87458     return (Dali::CustomActor *)jarg1;
87459 }
87460
87461 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
87462     return (Dali::BaseHandle *)jarg1;
87463 }
87464
87465 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
87466     return (Dali::Toolkit::Control *)jarg1;
87467 }
87468
87469 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
87470     return (Dali::Toolkit::Control *)jarg1;
87471 }
87472
87473 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
87474     return (Dali::Toolkit::Button *)jarg1;
87475 }
87476
87477 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
87478     return (Dali::Toolkit::Button *)jarg1;
87479 }
87480
87481 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
87482     return (Dali::Toolkit::Button *)jarg1;
87483 }
87484
87485 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
87486     return (Dali::Toolkit::Control *)jarg1;
87487 }
87488
87489 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
87490     return (Dali::Toolkit::Control *)jarg1;
87491 }
87492
87493 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
87494     return (Dali::Toolkit::Control *)jarg1;
87495 }
87496
87497 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
87498     return (Dali::Toolkit::Control *)jarg1;
87499 }
87500
87501 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
87502     return (Dali::Toolkit::Control *)jarg1;
87503 }
87504
87505 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
87506     return (Dali::RefObject *)jarg1;
87507 }
87508
87509 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
87510     return (Dali::Toolkit::Scrollable *)jarg1;
87511 }
87512
87513 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
87514     return (Dali::BaseHandle *)jarg1;
87515 }
87516
87517 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
87518     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
87519 }
87520
87521 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
87522     return (Dali::RefObject *)jarg1;
87523 }
87524
87525 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
87526     return (Dali::Toolkit::Ruler *)jarg1;
87527 }
87528
87529 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
87530     return (Dali::Toolkit::Ruler *)jarg1;
87531 }
87532
87533 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
87534     return (Dali::Toolkit::Scrollable *)jarg1;
87535 }
87536
87537 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
87538     return (Dali::Toolkit::Control *)jarg1;
87539 }
87540
87541
87542 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
87543     return (Dali::Toolkit::Control *)jarg1;
87544 }
87545
87546 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
87547     return (Dali::BaseHandle *)jarg1;
87548 }
87549
87550 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
87551     return (Dali::BaseHandle *)jarg1;
87552 }
87553
87554 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
87555     return (Dali::Toolkit::Control *)jarg1;
87556 }
87557
87558 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
87559     return (Dali::Toolkit::Control *)jarg1;
87560 }
87561
87562 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
87563     return (Dali::Toolkit::Control *)jarg1;
87564 }
87565
87566 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
87567     return (Dali::Toolkit::Control *)jarg1;
87568 }
87569
87570 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
87571     return (Dali::Toolkit::Control *)jarg1;
87572 }
87573
87574 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
87575     return (Dali::Toolkit::Control *)jarg1;
87576 }
87577
87578 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
87579     return (Dali::Toolkit::PageTurnView *)jarg1;
87580 }
87581
87582 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
87583     return (Dali::Toolkit::PageTurnView *)jarg1;
87584 }
87585
87586 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
87587     return (Dali::Toolkit::Button *)jarg1;
87588 }
87589
87590 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
87591     return (Dali::BaseHandle *)jarg1;
87592 }
87593
87594 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
87595     return (Dali::BaseHandle *)jarg1;
87596 }
87597
87598 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
87599     return (Dali::BaseHandle *)jarg1;
87600 }
87601
87602
87603 #ifdef __cplusplus
87604 }
87605 #endif