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 #include <dali/devel-api/events/key-event-devel.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/animation/animation-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/scrollable/scroll-view/scroll-view-devel.h>
 458 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
 459 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 460
 461 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 462 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 463 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 464
 465 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469
 470 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 471
 472
 473
 474 // add here SWIG version check
 475
 476 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 477 // disable Swig-dependent warnings
 478
 479 // 'identifier1' has C-linkage specified,
 480 // but returns UDT 'identifier2' which is incompatible with C
 481 #pragma warning(disable: 4190)
 482
 483 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 484 #pragma warning(disable: 4800)
 485
 486 // debug info too long etc etc
 487 #pragma warning(disable: 4786)
 488 #endif
 489
 490
 491 #include <stdexcept>
 492
 493
 494 #include <string>
 495
 496
 497 #include <vector>
 498 #include <algorithm>
 499 #include <stdexcept>
 500
 501
 502 #include <map>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <utility>
 508
 509
 510 typedef float floatp;
 511
 512 SWIGINTERN floatp *new_floatp(){
 513   return new float();
 514 }
 515 SWIGINTERN void delete_floatp(floatp *self){
 516   if (self) delete self;
 517 }
 518 SWIGINTERN void floatp_assign(floatp *self,float value){
 519   *self = value;
 520 }
 521 SWIGINTERN float floatp_value(floatp *self){
 522   return *self;
 523 }
 524 SWIGINTERN float *floatp_cast(floatp *self){
 525   return self;
 526 }
 527 SWIGINTERN floatp *floatp_frompointer(float *t){
 528   return (floatp *) t;
 529 }
 530
 531 typedef int intp;
 532
 533 SWIGINTERN intp *new_intp(){
 534   return new int();
 535 }
 536 SWIGINTERN void delete_intp(intp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void intp_assign(intp *self,int value){
 540   *self = value;
 541 }
 542 SWIGINTERN int intp_value(intp *self){
 543   return *self;
 544 }
 545 SWIGINTERN int *intp_cast(intp *self){
 546   return self;
 547 }
 548 SWIGINTERN intp *intp_frompointer(int *t){
 549   return (intp *) t;
 550 }
 551
 552 typedef double doublep;
 553
 554 SWIGINTERN doublep *new_doublep(){
 555   return new double();
 556 }
 557 SWIGINTERN void delete_doublep(doublep *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void doublep_assign(doublep *self,double value){
 561   *self = value;
 562 }
 563 SWIGINTERN double doublep_value(doublep *self){
 564   return *self;
 565 }
 566 SWIGINTERN double *doublep_cast(doublep *self){
 567   return self;
 568 }
 569 SWIGINTERN doublep *doublep_frompointer(double *t){
 570   return (doublep *) t;
 571 }
 572
 573 typedef unsigned int uintp;
 574
 575 SWIGINTERN uintp *new_uintp(){
 576   return new unsigned int();
 577 }
 578 SWIGINTERN void delete_uintp(uintp *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 582   *self = value;
 583 }
 584 SWIGINTERN unsigned int uintp_value(uintp *self){
 585   return *self;
 586 }
 587 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 588   return self;
 589 }
 590 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 591   return (uintp *) t;
 592 }
 593
 594 typedef unsigned short ushortp;
 595
 596 SWIGINTERN ushortp *new_ushortp(){
 597   return new unsigned short();
 598 }
 599 SWIGINTERN void delete_ushortp(ushortp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 609   return self;
 610 }
 611 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 612   return (ushortp *) t;
 613 }
 614
 615 unsigned int int_to_uint(int x) {
 616    return (unsigned int) x;
 617 }
 618
 619
 620 using namespace Dali;
 621 using namespace Dali::Toolkit;
 622
 623 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 624
 625      // C++ code. DALi uses Handle <-> Body design pattern.
 626      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 627      // Handles in DALi can be converted into a boolean type
 628      // to check if the handle has a valid body attached to it.
 629      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 630      if( *self )
 631      {
 632        return true;
 633      }
 634      else
 635      {
 636        return false;
 637      }
 638     }
 639 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 640
 641      // C++ code. Check if two handles reference the same implemtion
 642      if( *self == rhs)
 643      {
 644        return true;
 645      }
 646      else
 647      {
 648        return false;
 649      }
 650     }
 651 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 652      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 653    }
 654 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){
 655      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 656    }
 657 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 658         std::vector< Dali::TouchPoint >* pv = 0;
 659         if (capacity >= 0) {
 660           pv = new std::vector< Dali::TouchPoint >();
 661           pv->reserve(capacity);
 662        } else {
 663           throw std::out_of_range("capacity");
 664        }
 665        return pv;
 666       }
 667 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 668         if (index>=0 && index<(int)self->size())
 669           return (*self)[index];
 670         else
 671           throw std::out_of_range("index");
 672       }
 673 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 674         if (index>=0 && index<(int)self->size())
 675           return (*self)[index];
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 680         if (index>=0 && index<(int)self->size())
 681           (*self)[index] = val;
 682         else
 683           throw std::out_of_range("index");
 684       }
 685 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 686         self->insert(self->end(), values.begin(), values.end());
 687       }
 688 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 689         if (index < 0)
 690           throw std::out_of_range("index");
 691         if (count < 0)
 692           throw std::out_of_range("count");
 693         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 694           throw std::invalid_argument("invalid range");
 695         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 696       }
 697 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 698         if (index>=0 && index<(int)self->size()+1)
 699           self->insert(self->begin()+index, x);
 700         else
 701           throw std::out_of_range("index");
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 704         if (index>=0 && index<(int)self->size()+1)
 705           self->insert(self->begin()+index, values.begin(), values.end());
 706         else
 707           throw std::out_of_range("index");
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 710         if (index>=0 && index<(int)self->size())
 711           self->erase(self->begin() + index);
 712         else
 713           throw std::out_of_range("index");
 714       }
 715 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 716         if (index < 0)
 717           throw std::out_of_range("index");
 718         if (count < 0)
 719           throw std::out_of_range("count");
 720         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 721           throw std::invalid_argument("invalid range");
 722         self->erase(self->begin()+index, self->begin()+index+count);
 723       }
 724 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 725         if (count < 0)
 726           throw std::out_of_range("count");
 727         return new std::vector< Dali::TouchPoint >(count, value);
 728       }
 729 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 730         std::reverse(self->begin(), self->end());
 731       }
 732 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 733         if (index < 0)
 734           throw std::out_of_range("index");
 735         if (count < 0)
 736           throw std::out_of_range("count");
 737         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 738           throw std::invalid_argument("invalid range");
 739         std::reverse(self->begin()+index, self->begin()+index+count);
 740       }
 741 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 742         if (index < 0)
 743           throw std::out_of_range("index");
 744         if (index+values.size() > self->size())
 745           throw std::out_of_range("index");
 746         std::copy(values.begin(), values.end(), self->begin()+index);
 747       }
 748 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 749          return self->Empty();
 750       }
 751 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 752         return self->GetConnectionCount();
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 755           self->Connect( func );
 756       }
 757 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 758           self->Disconnect( func );
 759       }
 760 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 761           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 762 /*@SWIG@*/ self->Emit( arg );
 763       }
 764 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 765          return self->Empty();
 766       }
 767 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 768         return self->GetConnectionCount();
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 771           self->Connect( func );
 772       }
 773 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 774           self->Disconnect( func );
 775       }
 776 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 777           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 778 /*@SWIG@*/ self->Emit( arg );
 779       }
 780 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 781          return self->Empty();
 782       }
 783 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){
 784         return self->GetConnectionCount();
 785       }
 786 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 *)){
 787           self->Connect( func );
 788       }
 789 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 *)){
 790           self->Disconnect( func );
 791       }
 792 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){
 793           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 794 /*@SWIG@*/ self->Emit( arg );
 795       }
 796 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 797          return self->Empty();
 798       }
 799 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 800         return self->GetConnectionCount();
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 803           self->Connect( func );
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 806           self->Disconnect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 809           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 810 /*@SWIG@*/ self->Emit( arg );
 811       }
 812 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 813          return self->Empty();
 814       }
 815 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 816         return self->GetConnectionCount();
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 819           self->Connect( func );
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 822           self->Disconnect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 825           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 826 /*@SWIG@*/ self->Emit( arg );
 827       }
 828 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){
 829          return self->Empty();
 830       }
 831 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){
 832         return self->GetConnectionCount();
 833       }
 834 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 &)){
 835         self->Connect( func );
 836       }
 837 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 &)){
 838         self->Disconnect( func );
 839       }
 840 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){
 841         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 842 /*@SWIG@*/ self->Emit( arg1, arg2 );
 843       }
 844 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){
 845          return self->Empty();
 846       }
 847 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){
 848         return self->GetConnectionCount();
 849       }
 850 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 &)){
 851         self->Connect( func );
 852       }
 853 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 &)){
 854         self->Disconnect( func );
 855       }
 856 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){
 857         return self->Emit( arg1, arg2 );
 858       }
 859 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){
 860          return self->Empty();
 861       }
 862 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){
 863         return self->GetConnectionCount();
 864       }
 865 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 &)){
 866         self->Connect( func );
 867       }
 868 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 &)){
 869         self->Disconnect( func );
 870       }
 871 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){
 872         return self->Emit( arg1, arg2 );
 873       }
 874 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){
 875          return self->Empty();
 876       }
 877 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){
 878         return self->GetConnectionCount();
 879       }
 880 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 &)){
 881         self->Connect( func );
 882       }
 883 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 &)){
 884         self->Disconnect( func );
 885       }
 886 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){
 887         return self->Emit( arg1, arg2 );
 888       }
 889 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 890          return self->Empty();
 891       }
 892 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 893         return self->GetConnectionCount();
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 896           self->Connect( func );
 897       }
 898 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 899           self->Disconnect( func );
 900       }
 901 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 902           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 903 /*@SWIG@*/ self->Emit( arg );
 904       }
 905 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 906          return self->Empty();
 907       }
 908 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){
 909         return self->GetConnectionCount();
 910       }
 911 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 &)){
 912           self->Connect( func );
 913       }
 914 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 &)){
 915           self->Disconnect( func );
 916       }
 917 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){
 918           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 919 /*@SWIG@*/ self->Emit( arg );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928           self->Connect( func );
 929       }
 930 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 &)){
 931           self->Disconnect( func );
 932       }
 933 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){
 934           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 935 /*@SWIG@*/ self->Emit( arg );
 936       }
 937 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 938          return self->Empty();
 939       }
 940 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){
 941         return self->GetConnectionCount();
 942       }
 943 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 &)){
 944           self->Connect( func );
 945       }
 946 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 &)){
 947           self->Disconnect( func );
 948       }
 949 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){
 950           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 951 /*@SWIG@*/ self->Emit( arg );
 952       }
 953 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){
 954          return self->Empty();
 955       }
 956 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){
 957         return self->GetConnectionCount();
 958       }
 959 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 &)){
 960         self->Connect( func );
 961       }
 962 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 &)){
 963         self->Disconnect( func );
 964       }
 965 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){
 966         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 967 /*@SWIG@*/ self->Emit( arg1, arg2 );
 968       }
 969 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){
 970          return self->Empty();
 971       }
 972 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){
 973         return self->GetConnectionCount();
 974       }
 975 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 &)){
 976         self->Connect( func );
 977       }
 978 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 &)){
 979         self->Disconnect( func );
 980       }
 981 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){
 982         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 983 /*@SWIG@*/ self->Emit( arg1, arg2 );
 984       }
 985 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){
 986          return self->Empty();
 987       }
 988 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){
 989         return self->GetConnectionCount();
 990       }
 991 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 &)){
 992         self->Connect( func );
 993       }
 994 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 &)){
 995         self->Disconnect( func );
 996       }
 997 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){
 998         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 999 /*@SWIG@*/ self->Emit( arg1, arg2 );
1000       }
1001 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1002          return self->Empty();
1003       }
1004 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1005         return self->GetConnectionCount();
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1008           self->Connect( func );
1009       }
1010 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1011           self->Disconnect( func );
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1014           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1015 /*@SWIG@*/ self->Emit( arg );
1016       }
1017 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1018          return self->Empty();
1019       }
1020 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1021         return self->GetConnectionCount();
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1024           self->Connect( func );
1025       }
1026 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1027           self->Disconnect( func );
1028       }
1029 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1030           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1031 /*@SWIG@*/ self->Emit( arg );
1032       }
1033 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){
1034          return self->Empty();
1035       }
1036 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){
1037         return self->GetConnectionCount();
1038       }
1039 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)){
1040           return self->Connect( func );
1041       }
1042 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)){
1043           self->Disconnect( func );
1044       }
1045 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){
1046           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1047 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1048       }
1049
1050 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1051          return self->Empty();
1052       }
1053 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1054         return self->GetConnectionCount();
1055       }
1056 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1057           self->Connect( func );
1058       }
1059 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1060           self->Disconnect( func );
1061       }
1062 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1063           return self->Emit();
1064       }
1065
1066 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1067         std::vector< unsigned int >* pv = 0;
1068         if (capacity >= 0) {
1069           pv = new std::vector< unsigned int >();
1070           pv->reserve(capacity);
1071        } else {
1072           throw std::out_of_range("capacity");
1073        }
1074        return pv;
1075       }
1076 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           return (*self)[index];
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1083         if (index>=0 && index<(int)self->size())
1084           return (*self)[index];
1085         else
1086           throw std::out_of_range("index");
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1089         if (index>=0 && index<(int)self->size())
1090           (*self)[index] = val;
1091         else
1092           throw std::out_of_range("index");
1093       }
1094 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1095         self->insert(self->end(), values.begin(), values.end());
1096       }
1097 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1098         if (index < 0)
1099           throw std::out_of_range("index");
1100         if (count < 0)
1101           throw std::out_of_range("count");
1102         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1103           throw std::invalid_argument("invalid range");
1104         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1107         if (index>=0 && index<(int)self->size()+1)
1108           self->insert(self->begin()+index, x);
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1113         if (index>=0 && index<(int)self->size()+1)
1114           self->insert(self->begin()+index, values.begin(), values.end());
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1119         if (index>=0 && index<(int)self->size())
1120           self->erase(self->begin() + index);
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1125         if (index < 0)
1126           throw std::out_of_range("index");
1127         if (count < 0)
1128           throw std::out_of_range("count");
1129         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1130           throw std::invalid_argument("invalid range");
1131         self->erase(self->begin()+index, self->begin()+index+count);
1132       }
1133 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1134         if (count < 0)
1135           throw std::out_of_range("count");
1136         return new std::vector< unsigned int >(count, value);
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1139         std::reverse(self->begin(), self->end());
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1142         if (index < 0)
1143           throw std::out_of_range("index");
1144         if (count < 0)
1145           throw std::out_of_range("count");
1146         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1147           throw std::invalid_argument("invalid range");
1148         std::reverse(self->begin()+index, self->begin()+index+count);
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1151         if (index < 0)
1152           throw std::out_of_range("index");
1153         if (index+values.size() > self->size())
1154           throw std::out_of_range("index");
1155         std::copy(values.begin(), values.end(), self->begin()+index);
1156       }
1157 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1158         return std::find(self->begin(), self->end(), value) != self->end();
1159       }
1160 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1161         int index = -1;
1162         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1163         if (it != self->end())
1164           index = (int)(it - self->begin());
1165         return index;
1166       }
1167 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1168         int index = -1;
1169         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1170         if (rit != self->rend())
1171           index = (int)(self->rend() - 1 - rit);
1172         return index;
1173       }
1174 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1175         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1176         if (it != self->end()) {
1177           self->erase(it);
1178           return true;
1179         }
1180         return false;
1181       }
1182 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){
1183         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1184         if (capacity >= 0) {
1185           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1186           pv->reserve(capacity);
1187        } else {
1188           throw std::out_of_range("capacity");
1189        }
1190        return pv;
1191       }
1192 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){
1193         if (index>=0 && index<(int)self->size())
1194           return (*self)[index];
1195         else
1196           throw std::out_of_range("index");
1197       }
1198 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){
1199         if (index>=0 && index<(int)self->size())
1200           return (*self)[index];
1201         else
1202           throw std::out_of_range("index");
1203       }
1204 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){
1205         if (index>=0 && index<(int)self->size())
1206           (*self)[index] = val;
1207         else
1208           throw std::out_of_range("index");
1209       }
1210 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1211         self->insert(self->end(), values.begin(), values.end());
1212       }
1213 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){
1214         if (index < 0)
1215           throw std::out_of_range("index");
1216         if (count < 0)
1217           throw std::out_of_range("count");
1218         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1219           throw std::invalid_argument("invalid range");
1220         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1221       }
1222 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){
1223         if (index>=0 && index<(int)self->size()+1)
1224           self->insert(self->begin()+index, x);
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size()+1)
1230           self->insert(self->begin()+index, values.begin(), values.end());
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           self->erase(self->begin() + index);
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         if (index < 0)
1242           throw std::out_of_range("index");
1243         if (count < 0)
1244           throw std::out_of_range("count");
1245         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1246           throw std::invalid_argument("invalid range");
1247         self->erase(self->begin()+index, self->begin()+index+count);
1248       }
1249 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){
1250         if (count < 0)
1251           throw std::out_of_range("count");
1252         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1253       }
1254 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){
1255         std::reverse(self->begin(), self->end());
1256       }
1257 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){
1258         if (index < 0)
1259           throw std::out_of_range("index");
1260         if (count < 0)
1261           throw std::out_of_range("count");
1262         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1263           throw std::invalid_argument("invalid range");
1264         std::reverse(self->begin()+index, self->begin()+index+count);
1265       }
1266 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){
1267         if (index < 0)
1268           throw std::out_of_range("index");
1269         if (index+values.size() > self->size())
1270           throw std::out_of_range("index");
1271         std::copy(values.begin(), values.end(), self->begin()+index);
1272       }
1273 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1274         std::vector< Dali::Actor >* pv = 0;
1275         if (capacity >= 0) {
1276           pv = new std::vector< Dali::Actor >();
1277           pv->reserve(capacity);
1278        } else {
1279           throw std::out_of_range("capacity");
1280        }
1281        return pv;
1282       }
1283 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           return (*self)[index];
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1290         if (index>=0 && index<(int)self->size())
1291           return (*self)[index];
1292         else
1293           throw std::out_of_range("index");
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1296         if (index>=0 && index<(int)self->size())
1297           (*self)[index] = val;
1298         else
1299           throw std::out_of_range("index");
1300       }
1301 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1302         self->insert(self->end(), values.begin(), values.end());
1303       }
1304 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1305         if (index < 0)
1306           throw std::out_of_range("index");
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1310           throw std::invalid_argument("invalid range");
1311         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1314         if (index>=0 && index<(int)self->size()+1)
1315           self->insert(self->begin()+index, x);
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1320         if (index>=0 && index<(int)self->size()+1)
1321           self->insert(self->begin()+index, values.begin(), values.end());
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1326         if (index>=0 && index<(int)self->size())
1327           self->erase(self->begin() + index);
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1332         if (index < 0)
1333           throw std::out_of_range("index");
1334         if (count < 0)
1335           throw std::out_of_range("count");
1336         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1337           throw std::invalid_argument("invalid range");
1338         self->erase(self->begin()+index, self->begin()+index+count);
1339       }
1340 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1341         if (count < 0)
1342           throw std::out_of_range("count");
1343         return new std::vector< Dali::Actor >(count, value);
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1346         std::reverse(self->begin(), self->end());
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1349         if (index < 0)
1350           throw std::out_of_range("index");
1351         if (count < 0)
1352           throw std::out_of_range("count");
1353         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1354           throw std::invalid_argument("invalid range");
1355         std::reverse(self->begin()+index, self->begin()+index+count);
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1358         if (index < 0)
1359           throw std::out_of_range("index");
1360         if (index+values.size() > self->size())
1361           throw std::out_of_range("index");
1362         std::copy(values.begin(), values.end(), self->begin()+index);
1363       }
1364 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1365          return self->Empty();
1366       }
1367 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1368         return self->GetConnectionCount();
1369       }
1370 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 &)){
1371           self->Connect( func );
1372       }
1373 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 &)){
1374           self->Disconnect( func );
1375       }
1376 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){
1377           return self->Emit( arg );
1378       }
1379 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){
1380          return self->Empty();
1381       }
1382 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){
1383         return self->GetConnectionCount();
1384       }
1385 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)){
1386         self->Connect( func );
1387       }
1388 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)){
1389         self->Disconnect( func );
1390       }
1391 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){
1392         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1393 /*@SWIG@*/ self->Emit( arg1, arg2 );
1394       }
1395 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1396          return self->Empty();
1397       }
1398 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){
1399         return self->GetConnectionCount();
1400       }
1401 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)){
1402         self->Connect( func );
1403       }
1404 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)){
1405         self->Disconnect( func );
1406       }
1407 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){
1408         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1409 /*@SWIG@*/ self->Emit( arg1, arg2 );
1410       }
1411 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1412          return self->Empty();
1413       }
1414 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1415         return self->GetConnectionCount();
1416       }
1417 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)){
1418         self->Connect( func );
1419       }
1420 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)){
1421         self->Disconnect( func );
1422       }
1423 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){
1424         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1425 /*@SWIG@*/ self->Emit( arg1, arg2 );
1426       }
1427 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){
1428          return self->Empty();
1429       }
1430 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){
1431         return self->GetConnectionCount();
1432       }
1433 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)){
1434         self->Connect( func );
1435       }
1436 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)){
1437         self->Disconnect( func );
1438       }
1439 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){
1440         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1441 /*@SWIG@*/ self->Emit( arg1, arg2 );
1442       }
1443 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1444          return self->Empty();
1445       }
1446 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1447         return self->GetConnectionCount();
1448       }
1449 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)){
1450           self->Connect( func );
1451       }
1452 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)){
1453           self->Disconnect( func );
1454       }
1455 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1456           return self->Emit( arg );
1457       }
1458 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1459          return self->Empty();
1460       }
1461 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1462         return self->GetConnectionCount();
1463       }
1464 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)){
1465           self->Connect( func );
1466       }
1467 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)){
1468           self->Disconnect( func );
1469       }
1470 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1471           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1472 /*@SWIG@*/ self->Emit( arg );
1473       }
1474 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){
1475          return self->Empty();
1476       }
1477 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){
1478         return self->GetConnectionCount();
1479       }
1480 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)){
1481           return self->Connect( func );
1482       }
1483 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)){
1484           self->Disconnect( func );
1485       }
1486 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){
1487           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1488 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1489       }
1490 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1491          return self->Empty();
1492       }
1493 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1494         return self->GetConnectionCount();
1495       }
1496 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)){
1497           self->Connect( func );
1498       }
1499 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)){
1500           self->Disconnect( func );
1501       }
1502 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1503           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1504 /*@SWIG@*/ self->Emit( arg );
1505       }
1506 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){
1507          return self->Empty();
1508       }
1509 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){
1510         return self->GetConnectionCount();
1511       }
1512 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)){
1513           return self->Connect( func );
1514       }
1515 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)){
1516           self->Disconnect( func );
1517       }
1518 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){
1519           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1520 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1521       }
1522 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){
1523          return self->Empty();
1524       }
1525 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){
1526         return self->GetConnectionCount();
1527       }
1528 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 &)){
1529           self->Connect( func );
1530       }
1531 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 &)){
1532           self->Disconnect( func );
1533       }
1534 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){
1535           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1536 /*@SWIG@*/ self->Emit( arg );
1537       }
1538 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1539          return self->Empty();
1540       }
1541 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){
1542         return self->GetConnectionCount();
1543       }
1544 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 &)){
1545           self->Connect( func );
1546       }
1547 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 &)){
1548           self->Disconnect( func );
1549       }
1550 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){
1551           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1552 /*@SWIG@*/ self->Emit( arg );
1553       }
1554
1555
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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 &)){
1563         self->Connect( func );
1564       }
1565 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 &)){
1566         self->Disconnect( func );
1567       }
1568 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){
1569         return self->Emit( arg1, arg2 );
1570       }
1571 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1572          return self->Empty();
1573       }
1574 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1575         return self->GetConnectionCount();
1576       }
1577 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)){
1578           self->Connect( func );
1579       }
1580 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)){
1581           self->Disconnect( func );
1582       }
1583 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1584           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1585 /*@SWIG@*/ self->Emit( arg );
1586       }
1587 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1588          return self->Empty();
1589       }
1590 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1591         return self->GetConnectionCount();
1592       }
1593 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 &)){
1594           self->Connect( func );
1595       }
1596 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 &)){
1597           self->Disconnect( func );
1598       }
1599 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){
1600           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1601 /*@SWIG@*/ self->Emit( arg );
1602       }
1603 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1604          return self->Empty();
1605       }
1606 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){
1607         return self->GetConnectionCount();
1608       }
1609 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)){
1610         self->Connect( func );
1611       }
1612 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)){
1613         self->Disconnect( func );
1614       }
1615 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){
1616         return self->Emit( arg1, arg2 );
1617       }
1618 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1619          return self->Empty();
1620       }
1621 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){
1622         return self->GetConnectionCount();
1623       }
1624 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)){
1625         self->Connect( func );
1626       }
1627 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)){
1628         self->Disconnect( func );
1629       }
1630 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){
1631         return self->Emit( arg1, arg2 );
1632       }
1633
1634
1635 /* ---------------------------------------------------
1636  * C++ director class methods
1637  * --------------------------------------------------- */
1638
1639 #include "dali_wrap.h"
1640
1641 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1642   swig_init_callbacks();
1643 }
1644
1645 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1646
1647 }
1648
1649
1650 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1651   int jdepth  ;
1652
1653   if (!swig_callbackOnStageConnection) {
1654     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1655     return;
1656   } else {
1657     jdepth = depth;
1658     swig_callbackOnStageConnection(jdepth);
1659   }
1660 }
1661
1662 void SwigDirector_ViewImpl::OnStageDisconnection() {
1663   if (!swig_callbackOnStageDisconnection) {
1664     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1665     return;
1666   } else {
1667     swig_callbackOnStageDisconnection();
1668   }
1669 }
1670
1671 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1672   void * jchild = 0 ;
1673
1674   if (!swig_callbackOnChildAdd) {
1675     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1676     return;
1677   } else {
1678     jchild = (Dali::Actor *) &child;
1679     swig_callbackOnChildAdd(jchild);
1680   }
1681 }
1682
1683 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1684   void * jchild = 0 ;
1685
1686   if (!swig_callbackOnChildRemove) {
1687     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1688     return;
1689   } else {
1690     jchild = (Dali::Actor *) &child;
1691     swig_callbackOnChildRemove(jchild);
1692   }
1693 }
1694
1695 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1696   int jindex  ;
1697   void * jpropertyValue  ;
1698
1699   if (!swig_callbackOnPropertySet) {
1700     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1701     return;
1702   } else {
1703     jindex = index;
1704     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1705     swig_callbackOnPropertySet(jindex, jpropertyValue);
1706   }
1707 }
1708
1709 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1710   void * jtargetSize = 0 ;
1711
1712   if (!swig_callbackOnSizeSet) {
1713     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1714     return;
1715   } else {
1716     jtargetSize = (Dali::Vector3 *) &targetSize;
1717     swig_callbackOnSizeSet(jtargetSize);
1718   }
1719 }
1720
1721 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1722   void * janimation = 0 ;
1723   void * jtargetSize = 0 ;
1724
1725   if (!swig_callbackOnSizeAnimation) {
1726     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1727     return;
1728   } else {
1729     janimation = (Dali::Animation *) &animation;
1730     jtargetSize = (Dali::Vector3 *) &targetSize;
1731     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1732   }
1733 }
1734
1735 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1736   bool c_result = SwigValueInit< bool >() ;
1737   unsigned int jresult = 0 ;
1738   void * jarg0 = 0 ;
1739
1740   if (!swig_callbackOnTouchEvent) {
1741     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1742   } else {
1743     jarg0 = (Dali::TouchEvent *) &event;
1744     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1745     c_result = jresult ? true : false;
1746   }
1747   return c_result;
1748 }
1749
1750 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1751   bool c_result = SwigValueInit< bool >() ;
1752   unsigned int jresult = 0 ;
1753   void * jarg0 = 0 ;
1754
1755   if (!swig_callbackOnHoverEvent) {
1756     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1757   } else {
1758     jarg0 = (Dali::HoverEvent *) &event;
1759     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1760     c_result = jresult ? true : false;
1761   }
1762   return c_result;
1763 }
1764
1765 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1766   bool c_result = SwigValueInit< bool >() ;
1767   unsigned int jresult = 0 ;
1768   void * jarg0 = 0 ;
1769
1770   if (!swig_callbackOnKeyEvent) {
1771     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1772   } else {
1773     jarg0 = (Dali::KeyEvent *) &event;
1774     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1775     c_result = jresult ? true : false;
1776   }
1777   return c_result;
1778 }
1779
1780 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1781   bool c_result = SwigValueInit< bool >() ;
1782   unsigned int jresult = 0 ;
1783   void * jarg0 = 0 ;
1784
1785   if (!swig_callbackOnWheelEvent) {
1786     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1787   } else {
1788     jarg0 = (Dali::WheelEvent *) &event;
1789     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1790     c_result = jresult ? true : false;
1791   }
1792   return c_result;
1793 }
1794
1795 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1796   void * jsize = 0 ;
1797   void * jcontainer = 0 ;
1798
1799   if (!swig_callbackOnRelayout) {
1800     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1801     return;
1802   } else {
1803     jsize = (Dali::Vector2 *) &size;
1804     jcontainer = (Dali::RelayoutContainer *) &container;
1805     swig_callbackOnRelayout(jsize, jcontainer);
1806   }
1807 }
1808
1809 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1810   int jpolicy  ;
1811   int jdimension  ;
1812
1813   if (!swig_callbackOnSetResizePolicy) {
1814     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1815     return;
1816   } else {
1817     jpolicy = (int)policy;
1818     jdimension = (int)dimension;
1819     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1820   }
1821 }
1822
1823 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1824   Dali::Vector3 c_result ;
1825   void * jresult = 0 ;
1826
1827   if (!swig_callbackGetNaturalSize) {
1828     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1829   } else {
1830     jresult = (void *) swig_callbackGetNaturalSize();
1831     if (!jresult) {
1832       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1833       return c_result;
1834     }
1835     c_result = *(Dali::Vector3 *)jresult;
1836   }
1837   return c_result;
1838 }
1839
1840 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1841   float c_result = SwigValueInit< float >() ;
1842   float jresult = 0 ;
1843   void * jchild = 0 ;
1844   int jdimension  ;
1845
1846   if (!swig_callbackCalculateChildSize) {
1847     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1848   } else {
1849     jchild = (Dali::Actor *) &child;
1850     jdimension = (int)dimension;
1851     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1852     c_result = (float)jresult;
1853   }
1854   return c_result;
1855 }
1856
1857 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1858   float c_result = SwigValueInit< float >() ;
1859   float jresult = 0 ;
1860   float jwidth  ;
1861
1862   if (!swig_callbackGetHeightForWidth) {
1863     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1864   } else {
1865     jwidth = width;
1866     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1867     c_result = (float)jresult;
1868   }
1869   return c_result;
1870 }
1871
1872 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1873   float c_result = SwigValueInit< float >() ;
1874   float jresult = 0 ;
1875   float jheight  ;
1876
1877   if (!swig_callbackGetWidthForHeight) {
1878     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1879   } else {
1880     jheight = height;
1881     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1882     c_result = (float)jresult;
1883   }
1884   return c_result;
1885 }
1886
1887 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1888   bool c_result = SwigValueInit< bool >() ;
1889   unsigned int jresult = 0 ;
1890   int jdimension  ;
1891
1892   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1893     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1894   } else {
1895     jdimension = (int)dimension;
1896     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1897     c_result = jresult ? true : false;
1898   }
1899   return c_result;
1900 }
1901
1902 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1903   int jdimension  ;
1904
1905   if (!swig_callbackOnCalculateRelayoutSize) {
1906     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1907     return;
1908   } else {
1909     jdimension = (int)dimension;
1910     swig_callbackOnCalculateRelayoutSize(jdimension);
1911   }
1912 }
1913
1914 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1915   float jsize  ;
1916   int jdimension  ;
1917
1918   if (!swig_callbackOnLayoutNegotiated) {
1919     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1920     return;
1921   } else {
1922     jsize = size;
1923     jdimension = (int)dimension;
1924     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1925   }
1926 }
1927
1928 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1929   return Dali::CustomActorImpl::GetExtension();
1930 }
1931
1932 void SwigDirector_ViewImpl::OnInitialize() {
1933   if (!swig_callbackOnInitialize) {
1934     Dali::Toolkit::Internal::Control::OnInitialize();
1935     return;
1936   } else {
1937     swig_callbackOnInitialize();
1938   }
1939 }
1940
1941 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1942   void * jchild = 0 ;
1943
1944   if (!swig_callbackOnControlChildAdd) {
1945     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1946     return;
1947   } else {
1948     jchild = (Dali::Actor *) &child;
1949     swig_callbackOnControlChildAdd(jchild);
1950   }
1951 }
1952
1953 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1954   void * jchild = 0 ;
1955
1956   if (!swig_callbackOnControlChildRemove) {
1957     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1958     return;
1959   } else {
1960     jchild = (Dali::Actor *) &child;
1961     swig_callbackOnControlChildRemove(jchild);
1962   }
1963 }
1964
1965 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1966   void * jstyleManager  ;
1967   int jchange  ;
1968
1969   if (!swig_callbackOnStyleChange) {
1970     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1971     return;
1972   } else {
1973     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1974     jchange = (int)change;
1975     swig_callbackOnStyleChange(jstyleManager, jchange);
1976   }
1977 }
1978
1979 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1980   bool c_result = SwigValueInit< bool >() ;
1981   unsigned int jresult = 0 ;
1982
1983   if (!swig_callbackOnAccessibilityActivated) {
1984     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1985   } else {
1986     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1987     c_result = jresult ? true : false;
1988   }
1989   return c_result;
1990 }
1991
1992 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1993   bool c_result = SwigValueInit< bool >() ;
1994   unsigned int jresult = 0 ;
1995   void * jgesture  ;
1996
1997   if (!swig_callbackOnAccessibilityPan) {
1998     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1999   } else {
2000     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2001     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2002     c_result = jresult ? true : false;
2003   }
2004   return c_result;
2005 }
2006
2007 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2008   bool c_result = SwigValueInit< bool >() ;
2009   unsigned int jresult = 0 ;
2010   void * jtouchEvent = 0 ;
2011
2012   if (!swig_callbackOnAccessibilityTouch) {
2013     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2014   } else {
2015     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2016     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2017     c_result = jresult ? true : false;
2018   }
2019   return c_result;
2020 }
2021
2022 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2023   bool c_result = SwigValueInit< bool >() ;
2024   unsigned int jresult = 0 ;
2025   unsigned int jisIncrease  ;
2026
2027   if (!swig_callbackOnAccessibilityValueChange) {
2028     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2029   } else {
2030     jisIncrease = isIncrease;
2031     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2032     c_result = jresult ? true : false;
2033   }
2034   return c_result;
2035 }
2036
2037 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2038   bool c_result = SwigValueInit< bool >() ;
2039   unsigned int jresult = 0 ;
2040
2041   if (!swig_callbackOnAccessibilityZoom) {
2042     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2043   } else {
2044     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2045     c_result = jresult ? true : false;
2046   }
2047   return c_result;
2048 }
2049
2050 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2051   if (!swig_callbackOnKeyInputFocusGained) {
2052     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2053     return;
2054   } else {
2055     swig_callbackOnKeyInputFocusGained();
2056   }
2057 }
2058
2059 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2060   if (!swig_callbackOnKeyInputFocusLost) {
2061     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2062     return;
2063   } else {
2064     swig_callbackOnKeyInputFocusLost();
2065   }
2066 }
2067
2068 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2069   Dali::Actor c_result ;
2070   void * jresult = 0 ;
2071   void * jcurrentFocusedActor  ;
2072   int jdirection  ;
2073   unsigned int jloopEnabled  ;
2074
2075   if (!swig_callbackGetNextKeyboardFocusableActor) {
2076     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2077   } else {
2078     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2079     jdirection = (int)direction;
2080     jloopEnabled = loopEnabled;
2081     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2082     if (!jresult) {
2083       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2084       return c_result;
2085     }
2086     c_result = *(Dali::Actor *)jresult;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2092   void * jcommitedFocusableActor  ;
2093
2094   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2095     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2096     return;
2097   } else {
2098     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2099     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2100   }
2101 }
2102
2103 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2104   bool c_result = SwigValueInit< bool >() ;
2105   unsigned int jresult = 0 ;
2106
2107   if (!swig_callbackOnKeyboardEnter) {
2108     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2109   } else {
2110     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2111     c_result = jresult ? true : false;
2112   }
2113   return c_result;
2114 }
2115
2116 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2117   void * jpinch = 0 ;
2118
2119   if (!swig_callbackOnPinch) {
2120     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2121     return;
2122   } else {
2123     jpinch = (Dali::PinchGesture *) &pinch;
2124     swig_callbackOnPinch(jpinch);
2125   }
2126 }
2127
2128 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2129   void * jpan = 0 ;
2130
2131   if (!swig_callbackOnPan) {
2132     Dali::Toolkit::Internal::Control::OnPan(pan);
2133     return;
2134   } else {
2135     jpan = (Dali::PanGesture *) &pan;
2136     swig_callbackOnPan(jpan);
2137   }
2138 }
2139
2140 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2141   void * jtap = 0 ;
2142
2143   if (!swig_callbackOnTap) {
2144     Dali::Toolkit::Internal::Control::OnTap(tap);
2145     return;
2146   } else {
2147     jtap = (Dali::TapGesture *) &tap;
2148     swig_callbackOnTap(jtap);
2149   }
2150 }
2151
2152 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2153   void * jlongPress = 0 ;
2154
2155   if (!swig_callbackOnLongPress) {
2156     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2157     return;
2158   } else {
2159     jlongPress = (Dali::LongPressGesture *) &longPress;
2160     swig_callbackOnLongPress(jlongPress);
2161   }
2162 }
2163
2164 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2165   void * jslotObserver = 0 ;
2166   void * jcallback = 0 ;
2167
2168   if (!swig_callbackSignalConnected) {
2169     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2170     return;
2171   } else {
2172     jslotObserver = (void *) slotObserver;
2173     jcallback = (void *) callback;
2174     swig_callbackSignalConnected(jslotObserver, jcallback);
2175   }
2176 }
2177
2178 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2179   void * jslotObserver = 0 ;
2180   void * jcallback = 0 ;
2181
2182   if (!swig_callbackSignalDisconnected) {
2183     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2184     return;
2185   } else {
2186     jslotObserver = (void *) slotObserver;
2187     jcallback = (void *) callback;
2188     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2189   }
2190 }
2191
2192 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2193   return Dali::Toolkit::Internal::Control::GetControlExtension();
2194 }
2195
2196 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) {
2197   swig_callbackOnStageConnection = callbackOnStageConnection;
2198   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2199   swig_callbackOnChildAdd = callbackOnChildAdd;
2200   swig_callbackOnChildRemove = callbackOnChildRemove;
2201   swig_callbackOnPropertySet = callbackOnPropertySet;
2202   swig_callbackOnSizeSet = callbackOnSizeSet;
2203   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2204   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2205   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2206   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2207   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2208   swig_callbackOnRelayout = callbackOnRelayout;
2209   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2210   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2211   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2212   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2213   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2214   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2215   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2216   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2217   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2218   swig_callbackOnInitialize = callbackOnInitialize;
2219   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2220   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2221   swig_callbackOnStyleChange = callbackOnStyleChange;
2222   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2223   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2224   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2225   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2226   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2227   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2228   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2229   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2230   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2231   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2232   swig_callbackOnPinch = callbackOnPinch;
2233   swig_callbackOnPan = callbackOnPan;
2234   swig_callbackOnTap = callbackOnTap;
2235   swig_callbackOnLongPress = callbackOnLongPress;
2236   swig_callbackSignalConnected = callbackSignalConnected;
2237   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2238 }
2239
2240 void SwigDirector_ViewImpl::swig_init_callbacks() {
2241   swig_callbackOnStageConnection = 0;
2242   swig_callbackOnStageDisconnection = 0;
2243   swig_callbackOnChildAdd = 0;
2244   swig_callbackOnChildRemove = 0;
2245   swig_callbackOnPropertySet = 0;
2246   swig_callbackOnSizeSet = 0;
2247   swig_callbackOnSizeAnimation = 0;
2248   swig_callbackOnTouchEvent = 0;
2249   swig_callbackOnHoverEvent = 0;
2250   swig_callbackOnKeyEvent = 0;
2251   swig_callbackOnWheelEvent = 0;
2252   swig_callbackOnRelayout = 0;
2253   swig_callbackOnSetResizePolicy = 0;
2254   swig_callbackGetNaturalSize = 0;
2255   swig_callbackCalculateChildSize = 0;
2256   swig_callbackGetHeightForWidth = 0;
2257   swig_callbackGetWidthForHeight = 0;
2258   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2259   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2260   swig_callbackOnCalculateRelayoutSize = 0;
2261   swig_callbackOnLayoutNegotiated = 0;
2262   swig_callbackOnInitialize = 0;
2263   swig_callbackOnControlChildAdd = 0;
2264   swig_callbackOnControlChildRemove = 0;
2265   swig_callbackOnStyleChange = 0;
2266   swig_callbackOnAccessibilityActivated = 0;
2267   swig_callbackOnAccessibilityPan = 0;
2268   swig_callbackOnAccessibilityTouch = 0;
2269   swig_callbackOnAccessibilityValueChange = 0;
2270   swig_callbackOnAccessibilityZoom = 0;
2271   swig_callbackOnKeyInputFocusGained = 0;
2272   swig_callbackOnKeyInputFocusLost = 0;
2273   swig_callbackGetNextKeyboardFocusableActor = 0;
2274   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2275   swig_callbackOnKeyboardEnter = 0;
2276   swig_callbackOnPinch = 0;
2277   swig_callbackOnPan = 0;
2278   swig_callbackOnTap = 0;
2279   swig_callbackOnLongPress = 0;
2280   swig_callbackSignalConnected = 0;
2281   swig_callbackSignalDisconnected = 0;
2282 }
2283
2284 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2285   swig_init_callbacks();
2286 }
2287
2288 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2289
2290 }
2291
2292
2293 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2294   unsigned int c_result = SwigValueInit< unsigned int >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackGetNumberOfItems) {
2298     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2299   } else {
2300     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2301     c_result = (unsigned int)jresult;
2302   }
2303   return c_result;
2304 }
2305
2306 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2307   Dali::Actor c_result ;
2308   void * jresult = 0 ;
2309   unsigned int jitemId  ;
2310
2311   if (!swig_callbackNewItem) {
2312     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2313   } else {
2314     jitemId = itemId;
2315     jresult = (void *) swig_callbackNewItem(jitemId);
2316     if (!jresult) {
2317       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2318       return c_result;
2319     }
2320     c_result = *(Dali::Actor *)jresult;
2321   }
2322   return c_result;
2323 }
2324
2325 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2326   unsigned int jitemId  ;
2327   void * jactor  ;
2328
2329   if (!swig_callbackItemReleased) {
2330     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2331     return;
2332   } else {
2333     jitemId = itemId;
2334     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2335     swig_callbackItemReleased(jitemId, jactor);
2336   }
2337 }
2338
2339 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2340   return Dali::Toolkit::ItemFactory::GetExtension();
2341 }
2342
2343 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2344   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2345   swig_callbackNewItem = callbackNewItem;
2346   swig_callbackItemReleased = callbackItemReleased;
2347 }
2348
2349 void SwigDirector_ItemFactory::swig_init_callbacks() {
2350   swig_callbackGetNumberOfItems = 0;
2351   swig_callbackNewItem = 0;
2352   swig_callbackItemReleased = 0;
2353 }
2354
2355 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2356   swig_init_callbacks();
2357 }
2358
2359 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2360
2361 }
2362
2363
2364 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2365   Dali::Actor c_result ;
2366   void * jresult = 0 ;
2367   void * jcurrent  ;
2368   void * jproposed  ;
2369   int jdirection  ;
2370
2371   if (!swig_callbackGetNextFocusableActor) {
2372     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2373   } else {
2374     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2375     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2376     jdirection = (int)direction;
2377     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2378     if (!jresult) {
2379       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2380       return c_result;
2381     }
2382     c_result = *(Dali::Actor *)jresult;
2383   }
2384   return c_result;
2385 }
2386
2387 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2388   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2389 }
2390
2391 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2392   swig_callbackGetNextFocusableActor = 0;
2393 }
2394
2395
2396 #ifdef __cplusplus
2397 extern "C" {
2398 #endif
2399
2400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2401   void * jresult ;
2402   floatp *result = 0 ;
2403
2404   {
2405     try {
2406       result = (floatp *)new_floatp();
2407     } catch (std::out_of_range& e) {
2408       {
2409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2410       };
2411     } catch (std::exception& e) {
2412       {
2413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2414       };
2415     } catch (...) {
2416       {
2417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2418       };
2419     }
2420   }
2421   jresult = (void *)result;
2422   return jresult;
2423 }
2424
2425
2426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2427   floatp *arg1 = (floatp *) 0 ;
2428
2429   arg1 = (floatp *)jarg1;
2430   {
2431     try {
2432       delete_floatp(arg1);
2433     } catch (std::out_of_range& e) {
2434       {
2435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2436       };
2437     } catch (std::exception& e) {
2438       {
2439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2440       };
2441     } catch (...) {
2442       {
2443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2444       };
2445     }
2446   }
2447 }
2448
2449
2450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2451   floatp *arg1 = (floatp *) 0 ;
2452   float arg2 ;
2453
2454   arg1 = (floatp *)jarg1;
2455   arg2 = (float)jarg2;
2456   {
2457     try {
2458       floatp_assign(arg1,arg2);
2459     } catch (std::out_of_range& e) {
2460       {
2461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2462       };
2463     } catch (std::exception& e) {
2464       {
2465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2466       };
2467     } catch (...) {
2468       {
2469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2470       };
2471     }
2472   }
2473 }
2474
2475
2476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2477   float jresult ;
2478   floatp *arg1 = (floatp *) 0 ;
2479   float result;
2480
2481   arg1 = (floatp *)jarg1;
2482   {
2483     try {
2484       result = (float)floatp_value(arg1);
2485     } catch (std::out_of_range& e) {
2486       {
2487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2488       };
2489     } catch (std::exception& e) {
2490       {
2491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2492       };
2493     } catch (...) {
2494       {
2495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2496       };
2497     }
2498   }
2499   jresult = result;
2500   return jresult;
2501 }
2502
2503
2504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2505   void * jresult ;
2506   floatp *arg1 = (floatp *) 0 ;
2507   float *result = 0 ;
2508
2509   arg1 = (floatp *)jarg1;
2510   {
2511     try {
2512       result = (float *)floatp_cast(arg1);
2513     } catch (std::out_of_range& e) {
2514       {
2515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2516       };
2517     } catch (std::exception& e) {
2518       {
2519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2520       };
2521     } catch (...) {
2522       {
2523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2524       };
2525     }
2526   }
2527   jresult = (void *)result;
2528   return jresult;
2529 }
2530
2531
2532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2533   void * jresult ;
2534   float *arg1 = (float *) 0 ;
2535   floatp *result = 0 ;
2536
2537   arg1 = (float *)jarg1;
2538   {
2539     try {
2540       result = (floatp *)floatp_frompointer(arg1);
2541     } catch (std::out_of_range& e) {
2542       {
2543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2544       };
2545     } catch (std::exception& e) {
2546       {
2547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2548       };
2549     } catch (...) {
2550       {
2551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2552       };
2553     }
2554   }
2555   jresult = (void *)result;
2556   return jresult;
2557 }
2558
2559
2560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2561   void * jresult ;
2562   intp *result = 0 ;
2563
2564   {
2565     try {
2566       result = (intp *)new_intp();
2567     } catch (std::out_of_range& e) {
2568       {
2569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2570       };
2571     } catch (std::exception& e) {
2572       {
2573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2574       };
2575     } catch (...) {
2576       {
2577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2578       };
2579     }
2580   }
2581   jresult = (void *)result;
2582   return jresult;
2583 }
2584
2585
2586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2587   intp *arg1 = (intp *) 0 ;
2588
2589   arg1 = (intp *)jarg1;
2590   {
2591     try {
2592       delete_intp(arg1);
2593     } catch (std::out_of_range& e) {
2594       {
2595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2596       };
2597     } catch (std::exception& e) {
2598       {
2599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2600       };
2601     } catch (...) {
2602       {
2603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2604       };
2605     }
2606   }
2607 }
2608
2609
2610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2611   intp *arg1 = (intp *) 0 ;
2612   int arg2 ;
2613
2614   arg1 = (intp *)jarg1;
2615   arg2 = (int)jarg2;
2616   {
2617     try {
2618       intp_assign(arg1,arg2);
2619     } catch (std::out_of_range& e) {
2620       {
2621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2622       };
2623     } catch (std::exception& e) {
2624       {
2625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2626       };
2627     } catch (...) {
2628       {
2629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2630       };
2631     }
2632   }
2633 }
2634
2635
2636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2637   int jresult ;
2638   intp *arg1 = (intp *) 0 ;
2639   int result;
2640
2641   arg1 = (intp *)jarg1;
2642   {
2643     try {
2644       result = (int)intp_value(arg1);
2645     } catch (std::out_of_range& e) {
2646       {
2647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (std::exception& e) {
2650       {
2651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2652       };
2653     } catch (...) {
2654       {
2655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2656       };
2657     }
2658   }
2659   jresult = result;
2660   return jresult;
2661 }
2662
2663
2664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2665   void * jresult ;
2666   intp *arg1 = (intp *) 0 ;
2667   int *result = 0 ;
2668
2669   arg1 = (intp *)jarg1;
2670   {
2671     try {
2672       result = (int *)intp_cast(arg1);
2673     } catch (std::out_of_range& e) {
2674       {
2675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2676       };
2677     } catch (std::exception& e) {
2678       {
2679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2680       };
2681     } catch (...) {
2682       {
2683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2684       };
2685     }
2686   }
2687   jresult = (void *)result;
2688   return jresult;
2689 }
2690
2691
2692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2693   void * jresult ;
2694   int *arg1 = (int *) 0 ;
2695   intp *result = 0 ;
2696
2697   arg1 = (int *)jarg1;
2698   {
2699     try {
2700       result = (intp *)intp_frompointer(arg1);
2701     } catch (std::out_of_range& e) {
2702       {
2703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2704       };
2705     } catch (std::exception& e) {
2706       {
2707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (...) {
2710       {
2711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2712       };
2713     }
2714   }
2715   jresult = (void *)result;
2716   return jresult;
2717 }
2718
2719
2720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2721   void * jresult ;
2722   doublep *result = 0 ;
2723
2724   {
2725     try {
2726       result = (doublep *)new_doublep();
2727     } catch (std::out_of_range& e) {
2728       {
2729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (std::exception& e) {
2732       {
2733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741   jresult = (void *)result;
2742   return jresult;
2743 }
2744
2745
2746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2747   doublep *arg1 = (doublep *) 0 ;
2748
2749   arg1 = (doublep *)jarg1;
2750   {
2751     try {
2752       delete_doublep(arg1);
2753     } catch (std::out_of_range& e) {
2754       {
2755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2756       };
2757     } catch (std::exception& e) {
2758       {
2759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2760       };
2761     } catch (...) {
2762       {
2763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2764       };
2765     }
2766   }
2767 }
2768
2769
2770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2771   doublep *arg1 = (doublep *) 0 ;
2772   double arg2 ;
2773
2774   arg1 = (doublep *)jarg1;
2775   arg2 = (double)jarg2;
2776   {
2777     try {
2778       doublep_assign(arg1,arg2);
2779     } catch (std::out_of_range& e) {
2780       {
2781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2782       };
2783     } catch (std::exception& e) {
2784       {
2785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2786       };
2787     } catch (...) {
2788       {
2789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2790       };
2791     }
2792   }
2793 }
2794
2795
2796 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2797   double jresult ;
2798   doublep *arg1 = (doublep *) 0 ;
2799   double result;
2800
2801   arg1 = (doublep *)jarg1;
2802   {
2803     try {
2804       result = (double)doublep_value(arg1);
2805     } catch (std::out_of_range& e) {
2806       {
2807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2808       };
2809     } catch (std::exception& e) {
2810       {
2811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2812       };
2813     } catch (...) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2816       };
2817     }
2818   }
2819   jresult = result;
2820   return jresult;
2821 }
2822
2823
2824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2825   void * jresult ;
2826   doublep *arg1 = (doublep *) 0 ;
2827   double *result = 0 ;
2828
2829   arg1 = (doublep *)jarg1;
2830   {
2831     try {
2832       result = (double *)doublep_cast(arg1);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2840       };
2841     } catch (...) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2844       };
2845     }
2846   }
2847   jresult = (void *)result;
2848   return jresult;
2849 }
2850
2851
2852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2853   void * jresult ;
2854   double *arg1 = (double *) 0 ;
2855   doublep *result = 0 ;
2856
2857   arg1 = (double *)jarg1;
2858   {
2859     try {
2860       result = (doublep *)doublep_frompointer(arg1);
2861     } catch (std::out_of_range& e) {
2862       {
2863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2864       };
2865     } catch (std::exception& e) {
2866       {
2867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2868       };
2869     } catch (...) {
2870       {
2871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2872       };
2873     }
2874   }
2875   jresult = (void *)result;
2876   return jresult;
2877 }
2878
2879
2880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2881   void * jresult ;
2882   uintp *result = 0 ;
2883
2884   {
2885     try {
2886       result = (uintp *)new_uintp();
2887     } catch (std::out_of_range& e) {
2888       {
2889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2890       };
2891     } catch (std::exception& e) {
2892       {
2893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2894       };
2895     } catch (...) {
2896       {
2897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2898       };
2899     }
2900   }
2901   jresult = (void *)result;
2902   return jresult;
2903 }
2904
2905
2906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2907   uintp *arg1 = (uintp *) 0 ;
2908
2909   arg1 = (uintp *)jarg1;
2910   {
2911     try {
2912       delete_uintp(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2920       };
2921     } catch (...) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2924       };
2925     }
2926   }
2927 }
2928
2929
2930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2931   uintp *arg1 = (uintp *) 0 ;
2932   unsigned int arg2 ;
2933
2934   arg1 = (uintp *)jarg1;
2935   arg2 = (unsigned int)jarg2;
2936   {
2937     try {
2938       uintp_assign(arg1,arg2);
2939     } catch (std::out_of_range& e) {
2940       {
2941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2942       };
2943     } catch (std::exception& e) {
2944       {
2945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2946       };
2947     } catch (...) {
2948       {
2949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2950       };
2951     }
2952   }
2953 }
2954
2955
2956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2957   unsigned int jresult ;
2958   uintp *arg1 = (uintp *) 0 ;
2959   unsigned int result;
2960
2961   arg1 = (uintp *)jarg1;
2962   {
2963     try {
2964       result = (unsigned int)uintp_value(arg1);
2965     } catch (std::out_of_range& e) {
2966       {
2967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (std::exception& e) {
2970       {
2971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2976       };
2977     }
2978   }
2979   jresult = result;
2980   return jresult;
2981 }
2982
2983
2984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2985   void * jresult ;
2986   uintp *arg1 = (uintp *) 0 ;
2987   unsigned int *result = 0 ;
2988
2989   arg1 = (uintp *)jarg1;
2990   {
2991     try {
2992       result = (unsigned int *)uintp_cast(arg1);
2993     } catch (std::out_of_range& e) {
2994       {
2995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2996       };
2997     } catch (std::exception& e) {
2998       {
2999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3000       };
3001     } catch (...) {
3002       {
3003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3004       };
3005     }
3006   }
3007   jresult = (void *)result;
3008   return jresult;
3009 }
3010
3011
3012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3013   void * jresult ;
3014   unsigned int *arg1 = (unsigned int *) 0 ;
3015   uintp *result = 0 ;
3016
3017   arg1 = (unsigned int *)jarg1;
3018   {
3019     try {
3020       result = (uintp *)uintp_frompointer(arg1);
3021     } catch (std::out_of_range& e) {
3022       {
3023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3024       };
3025     } catch (std::exception& e) {
3026       {
3027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (...) {
3030       {
3031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3032       };
3033     }
3034   }
3035   jresult = (void *)result;
3036   return jresult;
3037 }
3038
3039
3040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3041   void * jresult ;
3042   ushortp *result = 0 ;
3043
3044   {
3045     try {
3046       result = (ushortp *)new_ushortp();
3047     } catch (std::out_of_range& e) {
3048       {
3049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3050       };
3051     } catch (std::exception& e) {
3052       {
3053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3054       };
3055     } catch (...) {
3056       {
3057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3058       };
3059     }
3060   }
3061   jresult = (void *)result;
3062   return jresult;
3063 }
3064
3065
3066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3067   ushortp *arg1 = (ushortp *) 0 ;
3068
3069   arg1 = (ushortp *)jarg1;
3070   {
3071     try {
3072       delete_ushortp(arg1);
3073     } catch (std::out_of_range& e) {
3074       {
3075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3076       };
3077     } catch (std::exception& e) {
3078       {
3079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3080       };
3081     } catch (...) {
3082       {
3083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3084       };
3085     }
3086   }
3087 }
3088
3089
3090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3091   ushortp *arg1 = (ushortp *) 0 ;
3092   unsigned short arg2 ;
3093
3094   arg1 = (ushortp *)jarg1;
3095   arg2 = (unsigned short)jarg2;
3096   {
3097     try {
3098       ushortp_assign(arg1,arg2);
3099     } catch (std::out_of_range& e) {
3100       {
3101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3102       };
3103     } catch (std::exception& e) {
3104       {
3105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3106       };
3107     } catch (...) {
3108       {
3109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3110       };
3111     }
3112   }
3113 }
3114
3115
3116 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3117   unsigned short jresult ;
3118   ushortp *arg1 = (ushortp *) 0 ;
3119   unsigned short result;
3120
3121   arg1 = (ushortp *)jarg1;
3122   {
3123     try {
3124       result = (unsigned short)ushortp_value(arg1);
3125     } catch (std::out_of_range& e) {
3126       {
3127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3128       };
3129     } catch (std::exception& e) {
3130       {
3131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3132       };
3133     } catch (...) {
3134       {
3135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3136       };
3137     }
3138   }
3139   jresult = result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3145   void * jresult ;
3146   ushortp *arg1 = (ushortp *) 0 ;
3147   unsigned short *result = 0 ;
3148
3149   arg1 = (ushortp *)jarg1;
3150   {
3151     try {
3152       result = (unsigned short *)ushortp_cast(arg1);
3153     } catch (std::out_of_range& e) {
3154       {
3155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3156       };
3157     } catch (std::exception& e) {
3158       {
3159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3160       };
3161     } catch (...) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3164       };
3165     }
3166   }
3167   jresult = (void *)result;
3168   return jresult;
3169 }
3170
3171
3172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3173   void * jresult ;
3174   unsigned short *arg1 = (unsigned short *) 0 ;
3175   ushortp *result = 0 ;
3176
3177   arg1 = (unsigned short *)jarg1;
3178   {
3179     try {
3180       result = (ushortp *)ushortp_frompointer(arg1);
3181     } catch (std::out_of_range& e) {
3182       {
3183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3184       };
3185     } catch (std::exception& e) {
3186       {
3187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3188       };
3189     } catch (...) {
3190       {
3191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3192       };
3193     }
3194   }
3195   jresult = (void *)result;
3196   return jresult;
3197 }
3198
3199
3200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3201   unsigned int jresult ;
3202   int arg1 ;
3203   unsigned int result;
3204
3205   arg1 = (int)jarg1;
3206   {
3207     try {
3208       result = (unsigned int)int_to_uint(arg1);
3209     } catch (std::out_of_range& e) {
3210       {
3211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3212       };
3213     } catch (std::exception& e) {
3214       {
3215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (...) {
3218       {
3219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3220       };
3221     }
3222   }
3223   jresult = result;
3224   return jresult;
3225 }
3226
3227
3228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3229   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3230
3231   arg1 = (Dali::RefObject *)jarg1;
3232   {
3233     try {
3234       (arg1)->Reference();
3235     } catch (std::out_of_range& e) {
3236       {
3237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3238       };
3239     } catch (std::exception& e) {
3240       {
3241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3242       };
3243     } catch (...) {
3244       {
3245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3246       };
3247     }
3248   }
3249 }
3250
3251
3252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3253   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3254
3255   arg1 = (Dali::RefObject *)jarg1;
3256   {
3257     try {
3258       (arg1)->Unreference();
3259     } catch (std::out_of_range& e) {
3260       {
3261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3262       };
3263     } catch (std::exception& e) {
3264       {
3265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3266       };
3267     } catch (...) {
3268       {
3269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3270       };
3271     }
3272   }
3273 }
3274
3275
3276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3277   int jresult ;
3278   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3279   int result;
3280
3281   arg1 = (Dali::RefObject *)jarg1;
3282   {
3283     try {
3284       result = (int)(arg1)->ReferenceCount();
3285     } catch (std::out_of_range& e) {
3286       {
3287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3288       };
3289     } catch (std::exception& e) {
3290       {
3291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (...) {
3294       {
3295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3296       };
3297     }
3298   }
3299   jresult = result;
3300   return jresult;
3301 }
3302
3303
3304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3305   void * jresult ;
3306   Dali::Any *result = 0 ;
3307
3308   {
3309     try {
3310       result = (Dali::Any *)new Dali::Any();
3311     } catch (std::out_of_range& e) {
3312       {
3313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3314       };
3315     } catch (std::exception& e) {
3316       {
3317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3318       };
3319     } catch (...) {
3320       {
3321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3322       };
3323     }
3324   }
3325   jresult = (void *)result;
3326   return jresult;
3327 }
3328
3329
3330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3331   Dali::Any *arg1 = (Dali::Any *) 0 ;
3332
3333   arg1 = (Dali::Any *)jarg1;
3334   {
3335     try {
3336       delete arg1;
3337     } catch (std::out_of_range& e) {
3338       {
3339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3340       };
3341     } catch (std::exception& e) {
3342       {
3343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (...) {
3346       {
3347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3348       };
3349     }
3350   }
3351 }
3352
3353
3354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3355   char *arg1 = (char *) 0 ;
3356
3357   arg1 = (char *)jarg1;
3358   {
3359     try {
3360       Dali::Any::AssertAlways((char const *)arg1);
3361     } catch (std::out_of_range& e) {
3362       {
3363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3364       };
3365     } catch (std::exception& e) {
3366       {
3367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3372       };
3373     }
3374   }
3375 }
3376
3377
3378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3379   void * jresult ;
3380   Dali::Any *arg1 = 0 ;
3381   Dali::Any *result = 0 ;
3382
3383   arg1 = (Dali::Any *)jarg1;
3384   if (!arg1) {
3385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3386     return 0;
3387   }
3388   {
3389     try {
3390       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3391     } catch (std::out_of_range& e) {
3392       {
3393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3394       };
3395     } catch (std::exception& e) {
3396       {
3397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3398       };
3399     } catch (...) {
3400       {
3401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3402       };
3403     }
3404   }
3405   jresult = (void *)result;
3406   return jresult;
3407 }
3408
3409
3410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3411   void * jresult ;
3412   Dali::Any *arg1 = (Dali::Any *) 0 ;
3413   Dali::Any *arg2 = 0 ;
3414   Dali::Any *result = 0 ;
3415
3416   arg1 = (Dali::Any *)jarg1;
3417   arg2 = (Dali::Any *)jarg2;
3418   if (!arg2) {
3419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3420     return 0;
3421   }
3422   {
3423     try {
3424       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3425     } catch (std::out_of_range& e) {
3426       {
3427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3428       };
3429     } catch (std::exception& e) {
3430       {
3431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3432       };
3433     } catch (...) {
3434       {
3435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3436       };
3437     }
3438   }
3439   jresult = (void *)result;
3440   return jresult;
3441 }
3442
3443
3444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3445   void * jresult ;
3446   Dali::Any *arg1 = (Dali::Any *) 0 ;
3447   std::type_info *result = 0 ;
3448
3449   arg1 = (Dali::Any *)jarg1;
3450   {
3451     try {
3452       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3453     } catch (std::out_of_range& e) {
3454       {
3455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3456       };
3457     } catch (std::exception& e) {
3458       {
3459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3460       };
3461     } catch (...) {
3462       {
3463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3464       };
3465     }
3466   }
3467   jresult = (void *)result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3473   unsigned int jresult ;
3474   Dali::Any *arg1 = (Dali::Any *) 0 ;
3475   bool result;
3476
3477   arg1 = (Dali::Any *)jarg1;
3478   {
3479     try {
3480       result = (bool)((Dali::Any const *)arg1)->Empty();
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (...) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3492       };
3493     }
3494   }
3495   jresult = result;
3496   return jresult;
3497 }
3498
3499
3500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3501   void * jresult ;
3502   std::type_info *arg1 = 0 ;
3503   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3504   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3505   Dali::Any::AnyContainerBase *result = 0 ;
3506
3507   arg1 = (std::type_info *)jarg1;
3508   if (!arg1) {
3509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3510     return 0;
3511   }
3512   arg2 = (Dali::Any::CloneFunc)jarg2;
3513   arg3 = (Dali::Any::DeleteFunc)jarg3;
3514   {
3515     try {
3516       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3517     } catch (std::out_of_range& e) {
3518       {
3519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (std::exception& e) {
3522       {
3523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3524       };
3525     } catch (...) {
3526       {
3527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3528       };
3529     }
3530   }
3531   jresult = (void *)result;
3532   return jresult;
3533 }
3534
3535
3536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3537   void * jresult ;
3538   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3539   std::type_info *result = 0 ;
3540
3541   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3542   {
3543     try {
3544       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3545     } catch (std::out_of_range& e) {
3546       {
3547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (std::exception& e) {
3550       {
3551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (...) {
3554       {
3555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3556       };
3557     }
3558   }
3559   jresult = (void *)result;
3560   return jresult;
3561 }
3562
3563
3564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3565   void * jresult ;
3566   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3567   ::std::type_info *result = 0 ;
3568
3569   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3570   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3571   jresult = (void *)result;
3572   return jresult;
3573 }
3574
3575
3576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3577   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3578   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3579
3580   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3581   arg2 = (Dali::Any::CloneFunc)jarg2;
3582   if (arg1) (arg1)->mCloneFunc = arg2;
3583 }
3584
3585
3586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3587   void * jresult ;
3588   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3589   Dali::Any::CloneFunc result;
3590
3591   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3592   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3593   jresult = (void *)result;
3594   return jresult;
3595 }
3596
3597
3598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3599   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3600   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3601
3602   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3603   arg2 = (Dali::Any::DeleteFunc)jarg2;
3604   if (arg1) (arg1)->mDeleteFunc = arg2;
3605 }
3606
3607
3608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3609   void * jresult ;
3610   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3611   Dali::Any::DeleteFunc result;
3612
3613   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3614   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3615   jresult = (void *)result;
3616   return jresult;
3617 }
3618
3619
3620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3621   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3622
3623   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3624   {
3625     try {
3626       delete arg1;
3627     } catch (std::out_of_range& e) {
3628       {
3629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3630       };
3631     } catch (std::exception& e) {
3632       {
3633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3634       };
3635     } catch (...) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3638       };
3639     }
3640   }
3641 }
3642
3643
3644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3645   Dali::Any *arg1 = (Dali::Any *) 0 ;
3646   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3647
3648   arg1 = (Dali::Any *)jarg1;
3649   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3650   if (arg1) (arg1)->mContainer = arg2;
3651 }
3652
3653
3654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3655   void * jresult ;
3656   Dali::Any *arg1 = (Dali::Any *) 0 ;
3657   Dali::Any::AnyContainerBase *result = 0 ;
3658
3659   arg1 = (Dali::Any *)jarg1;
3660   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3661   jresult = (void *)result;
3662   return jresult;
3663 }
3664
3665
3666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3667   char *arg1 = (char *) 0 ;
3668   char *arg2 = (char *) 0 ;
3669
3670   arg1 = (char *)jarg1;
3671   arg2 = (char *)jarg2;
3672   {
3673     try {
3674       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3675     } catch (std::out_of_range& e) {
3676       {
3677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3678       };
3679     } catch (std::exception& e) {
3680       {
3681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3686       };
3687     }
3688   }
3689 }
3690
3691
3692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3693   void * jresult ;
3694   char *arg1 = (char *) 0 ;
3695   char *arg2 = (char *) 0 ;
3696   Dali::DaliException *result = 0 ;
3697
3698   arg1 = (char *)jarg1;
3699   arg2 = (char *)jarg2;
3700   {
3701     try {
3702       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3703     } catch (std::out_of_range& e) {
3704       {
3705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3706       };
3707     } catch (std::exception& e) {
3708       {
3709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3710       };
3711     } catch (...) {
3712       {
3713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3714       };
3715     }
3716   }
3717   jresult = (void *)result;
3718   return jresult;
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3723   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3724   char *arg2 = (char *) 0 ;
3725
3726   arg1 = (Dali::DaliException *)jarg1;
3727   arg2 = (char *)jarg2;
3728   {
3729     if (arg2) {
3730       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3731       strcpy((char *)arg1->location, (const char *)arg2);
3732     } else {
3733       arg1->location = 0;
3734     }
3735   }
3736 }
3737
3738
3739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3740   char * jresult ;
3741   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3742   char *result = 0 ;
3743
3744   arg1 = (Dali::DaliException *)jarg1;
3745   result = (char *) ((arg1)->location);
3746   jresult = SWIG_csharp_string_callback((const char *)result);
3747   return jresult;
3748 }
3749
3750
3751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3752   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3753   char *arg2 = (char *) 0 ;
3754
3755   arg1 = (Dali::DaliException *)jarg1;
3756   arg2 = (char *)jarg2;
3757   {
3758     if (arg2) {
3759       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3760       strcpy((char *)arg1->condition, (const char *)arg2);
3761     } else {
3762       arg1->condition = 0;
3763     }
3764   }
3765 }
3766
3767
3768 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3769   char * jresult ;
3770   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3771   char *result = 0 ;
3772
3773   arg1 = (Dali::DaliException *)jarg1;
3774   result = (char *) ((arg1)->condition);
3775   jresult = SWIG_csharp_string_callback((const char *)result);
3776   return jresult;
3777 }
3778
3779
3780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3781   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3782
3783   arg1 = (Dali::DaliException *)jarg1;
3784   {
3785     try {
3786       delete arg1;
3787     } catch (std::out_of_range& e) {
3788       {
3789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3790       };
3791     } catch (std::exception& e) {
3792       {
3793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3794       };
3795     } catch (...) {
3796       {
3797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3798       };
3799     }
3800   }
3801 }
3802
3803
3804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3805   void * jresult ;
3806   Dali::Vector2 *result = 0 ;
3807
3808   {
3809     try {
3810       result = (Dali::Vector2 *)new Dali::Vector2();
3811     } catch (std::out_of_range& e) {
3812       {
3813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3814       };
3815     } catch (std::exception& e) {
3816       {
3817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3818       };
3819     } catch (...) {
3820       {
3821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3822       };
3823     }
3824   }
3825   jresult = (void *)result;
3826   return jresult;
3827 }
3828
3829
3830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3831   void * jresult ;
3832   float arg1 ;
3833   float arg2 ;
3834   Dali::Vector2 *result = 0 ;
3835
3836   arg1 = (float)jarg1;
3837   arg2 = (float)jarg2;
3838   {
3839     try {
3840       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3841     } catch (std::out_of_range& e) {
3842       {
3843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (std::exception& e) {
3846       {
3847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3848       };
3849     } catch (...) {
3850       {
3851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3852       };
3853     }
3854   }
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3861   void * jresult ;
3862   float *arg1 = (float *) 0 ;
3863   Dali::Vector2 *result = 0 ;
3864
3865   arg1 = jarg1;
3866   {
3867     try {
3868       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (...) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3880       };
3881     }
3882   }
3883   jresult = (void *)result;
3884
3885
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3891   void * jresult ;
3892   Dali::Vector3 *arg1 = 0 ;
3893   Dali::Vector2 *result = 0 ;
3894
3895   arg1 = (Dali::Vector3 *)jarg1;
3896   if (!arg1) {
3897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3898     return 0;
3899   }
3900   {
3901     try {
3902       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3903     } catch (std::out_of_range& e) {
3904       {
3905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (std::exception& e) {
3908       {
3909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3923   void * jresult ;
3924   Dali::Vector4 *arg1 = 0 ;
3925   Dali::Vector2 *result = 0 ;
3926
3927   arg1 = (Dali::Vector4 *)jarg1;
3928   if (!arg1) {
3929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3930     return 0;
3931   }
3932   {
3933     try {
3934       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3935     } catch (std::out_of_range& e) {
3936       {
3937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3938       };
3939     } catch (std::exception& e) {
3940       {
3941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3942       };
3943     } catch (...) {
3944       {
3945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3946       };
3947     }
3948   }
3949   jresult = (void *)result;
3950   return jresult;
3951 }
3952
3953
3954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3955   void * jresult ;
3956   Dali::Vector2 *result = 0 ;
3957
3958   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3959   jresult = (void *)result;
3960   return jresult;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3965   void * jresult ;
3966   Dali::Vector2 *result = 0 ;
3967
3968   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3975   void * jresult ;
3976   Dali::Vector2 *result = 0 ;
3977
3978   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3979   jresult = (void *)result;
3980   return jresult;
3981 }
3982
3983
3984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3985   void * jresult ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3989   jresult = (void *)result;
3990   return jresult;
3991 }
3992
3993
3994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3995   void * jresult ;
3996   Dali::Vector2 *result = 0 ;
3997
3998   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3999   jresult = (void *)result;
4000   return jresult;
4001 }
4002
4003
4004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4005   void * jresult ;
4006   Dali::Vector2 *result = 0 ;
4007
4008   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4009   jresult = (void *)result;
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4015   void * jresult ;
4016   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4017   float *arg2 = (float *) 0 ;
4018   Dali::Vector2 *result = 0 ;
4019
4020   arg1 = (Dali::Vector2 *)jarg1;
4021   arg2 = jarg2;
4022   {
4023     try {
4024       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4025     } catch (std::out_of_range& e) {
4026       {
4027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4028       };
4029     } catch (std::exception& e) {
4030       {
4031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4032       };
4033     } catch (...) {
4034       {
4035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4036       };
4037     }
4038   }
4039   jresult = (void *)result;
4040
4041
4042   return jresult;
4043 }
4044
4045
4046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4047   void * jresult ;
4048   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4049   Dali::Vector3 *arg2 = 0 ;
4050   Dali::Vector2 *result = 0 ;
4051
4052   arg1 = (Dali::Vector2 *)jarg1;
4053   arg2 = (Dali::Vector3 *)jarg2;
4054   if (!arg2) {
4055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4056     return 0;
4057   }
4058   {
4059     try {
4060       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4061     } catch (std::out_of_range& e) {
4062       {
4063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4064       };
4065     } catch (std::exception& e) {
4066       {
4067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4068       };
4069     } catch (...) {
4070       {
4071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4072       };
4073     }
4074   }
4075   jresult = (void *)result;
4076   return jresult;
4077 }
4078
4079
4080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4081   void * jresult ;
4082   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4083   Dali::Vector4 *arg2 = 0 ;
4084   Dali::Vector2 *result = 0 ;
4085
4086   arg1 = (Dali::Vector2 *)jarg1;
4087   arg2 = (Dali::Vector4 *)jarg2;
4088   if (!arg2) {
4089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4090     return 0;
4091   }
4092   {
4093     try {
4094       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4095     } catch (std::out_of_range& e) {
4096       {
4097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4098       };
4099     } catch (std::exception& e) {
4100       {
4101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4102       };
4103     } catch (...) {
4104       {
4105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4106       };
4107     }
4108   }
4109   jresult = (void *)result;
4110   return jresult;
4111 }
4112
4113
4114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4115   void * jresult ;
4116   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4117   Dali::Vector2 *arg2 = 0 ;
4118   Dali::Vector2 result;
4119
4120   arg1 = (Dali::Vector2 *)jarg1;
4121   arg2 = (Dali::Vector2 *)jarg2;
4122   if (!arg2) {
4123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4124     return 0;
4125   }
4126   {
4127     try {
4128       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4129     } catch (std::out_of_range& e) {
4130       {
4131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4132       };
4133     } catch (std::exception& e) {
4134       {
4135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4136       };
4137     } catch (...) {
4138       {
4139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4140       };
4141     }
4142   }
4143   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4144   return jresult;
4145 }
4146
4147
4148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4149   void * jresult ;
4150   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4151   Dali::Vector2 *arg2 = 0 ;
4152   Dali::Vector2 *result = 0 ;
4153
4154   arg1 = (Dali::Vector2 *)jarg1;
4155   arg2 = (Dali::Vector2 *)jarg2;
4156   if (!arg2) {
4157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4158     return 0;
4159   }
4160   {
4161     try {
4162       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4163     } catch (std::out_of_range& e) {
4164       {
4165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4166       };
4167     } catch (std::exception& e) {
4168       {
4169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4170       };
4171     } catch (...) {
4172       {
4173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4174       };
4175     }
4176   }
4177   jresult = (void *)result;
4178   return jresult;
4179 }
4180
4181
4182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4183   void * jresult ;
4184   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4185   Dali::Vector2 *arg2 = 0 ;
4186   Dali::Vector2 result;
4187
4188   arg1 = (Dali::Vector2 *)jarg1;
4189   arg2 = (Dali::Vector2 *)jarg2;
4190   if (!arg2) {
4191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4192     return 0;
4193   }
4194   {
4195     try {
4196       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4197     } catch (std::out_of_range& e) {
4198       {
4199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4200       };
4201     } catch (std::exception& e) {
4202       {
4203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4204       };
4205     } catch (...) {
4206       {
4207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4208       };
4209     }
4210   }
4211   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4212   return jresult;
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4217   void * jresult ;
4218   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4219   Dali::Vector2 *arg2 = 0 ;
4220   Dali::Vector2 *result = 0 ;
4221
4222   arg1 = (Dali::Vector2 *)jarg1;
4223   arg2 = (Dali::Vector2 *)jarg2;
4224   if (!arg2) {
4225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4226     return 0;
4227   }
4228   {
4229     try {
4230       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (...) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4242       };
4243     }
4244   }
4245   jresult = (void *)result;
4246   return jresult;
4247 }
4248
4249
4250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4251   void * jresult ;
4252   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4253   Dali::Vector2 *arg2 = 0 ;
4254   Dali::Vector2 result;
4255
4256   arg1 = (Dali::Vector2 *)jarg1;
4257   arg2 = (Dali::Vector2 *)jarg2;
4258   if (!arg2) {
4259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4260     return 0;
4261   }
4262   {
4263     try {
4264       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4265     } catch (std::out_of_range& e) {
4266       {
4267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4268       };
4269     } catch (std::exception& e) {
4270       {
4271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4272       };
4273     } catch (...) {
4274       {
4275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4276       };
4277     }
4278   }
4279   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4285   void * jresult ;
4286   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4287   float arg2 ;
4288   Dali::Vector2 result;
4289
4290   arg1 = (Dali::Vector2 *)jarg1;
4291   arg2 = (float)jarg2;
4292   {
4293     try {
4294       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4295     } catch (std::out_of_range& e) {
4296       {
4297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (std::exception& e) {
4300       {
4301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4310   return jresult;
4311 }
4312
4313
4314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4315   void * jresult ;
4316   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4317   Dali::Vector2 *arg2 = 0 ;
4318   Dali::Vector2 *result = 0 ;
4319
4320   arg1 = (Dali::Vector2 *)jarg1;
4321   arg2 = (Dali::Vector2 *)jarg2;
4322   if (!arg2) {
4323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4324     return 0;
4325   }
4326   {
4327     try {
4328       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4329     } catch (std::out_of_range& e) {
4330       {
4331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (std::exception& e) {
4334       {
4335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4336       };
4337     } catch (...) {
4338       {
4339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4340       };
4341     }
4342   }
4343   jresult = (void *)result;
4344   return jresult;
4345 }
4346
4347
4348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4349   void * jresult ;
4350   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4351   float arg2 ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   arg1 = (Dali::Vector2 *)jarg1;
4355   arg2 = (float)jarg2;
4356   {
4357     try {
4358       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4359     } catch (std::out_of_range& e) {
4360       {
4361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (std::exception& e) {
4364       {
4365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4366       };
4367     } catch (...) {
4368       {
4369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4370       };
4371     }
4372   }
4373   jresult = (void *)result;
4374   return jresult;
4375 }
4376
4377
4378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4379   void * jresult ;
4380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4381   Dali::Vector2 *arg2 = 0 ;
4382   Dali::Vector2 result;
4383
4384   arg1 = (Dali::Vector2 *)jarg1;
4385   arg2 = (Dali::Vector2 *)jarg2;
4386   if (!arg2) {
4387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4388     return 0;
4389   }
4390   {
4391     try {
4392       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4393     } catch (std::out_of_range& e) {
4394       {
4395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4396       };
4397     } catch (std::exception& e) {
4398       {
4399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4400       };
4401     } catch (...) {
4402       {
4403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4404       };
4405     }
4406   }
4407   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4413   void * jresult ;
4414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4415   float arg2 ;
4416   Dali::Vector2 result;
4417
4418   arg1 = (Dali::Vector2 *)jarg1;
4419   arg2 = (float)jarg2;
4420   {
4421     try {
4422       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4423     } catch (std::out_of_range& e) {
4424       {
4425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (std::exception& e) {
4428       {
4429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4430       };
4431     } catch (...) {
4432       {
4433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4434       };
4435     }
4436   }
4437   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4438   return jresult;
4439 }
4440
4441
4442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4443   void * jresult ;
4444   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4445   Dali::Vector2 *arg2 = 0 ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   arg1 = (Dali::Vector2 *)jarg1;
4449   arg2 = (Dali::Vector2 *)jarg2;
4450   if (!arg2) {
4451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4452     return 0;
4453   }
4454   {
4455     try {
4456       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4457     } catch (std::out_of_range& e) {
4458       {
4459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (std::exception& e) {
4462       {
4463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4464       };
4465     } catch (...) {
4466       {
4467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4468       };
4469     }
4470   }
4471   jresult = (void *)result;
4472   return jresult;
4473 }
4474
4475
4476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4477   void * jresult ;
4478   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4479   float arg2 ;
4480   Dali::Vector2 *result = 0 ;
4481
4482   arg1 = (Dali::Vector2 *)jarg1;
4483   arg2 = (float)jarg2;
4484   {
4485     try {
4486       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4487     } catch (std::out_of_range& e) {
4488       {
4489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (std::exception& e) {
4492       {
4493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4494       };
4495     } catch (...) {
4496       {
4497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4498       };
4499     }
4500   }
4501   jresult = (void *)result;
4502   return jresult;
4503 }
4504
4505
4506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4507   void * jresult ;
4508   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4509   Dali::Vector2 result;
4510
4511   arg1 = (Dali::Vector2 *)jarg1;
4512   {
4513     try {
4514       result = ((Dali::Vector2 const *)arg1)->operator -();
4515     } catch (std::out_of_range& e) {
4516       {
4517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (std::exception& e) {
4520       {
4521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4530   return jresult;
4531 }
4532
4533
4534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4535   unsigned int jresult ;
4536   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4537   Dali::Vector2 *arg2 = 0 ;
4538   bool result;
4539
4540   arg1 = (Dali::Vector2 *)jarg1;
4541   arg2 = (Dali::Vector2 *)jarg2;
4542   if (!arg2) {
4543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4544     return 0;
4545   }
4546   {
4547     try {
4548       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4549     } catch (std::out_of_range& e) {
4550       {
4551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4552       };
4553     } catch (std::exception& e) {
4554       {
4555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4556       };
4557     } catch (...) {
4558       {
4559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4560       };
4561     }
4562   }
4563   jresult = result;
4564   return jresult;
4565 }
4566
4567
4568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4569   unsigned int jresult ;
4570   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4571   Dali::Vector2 *arg2 = 0 ;
4572   bool result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   arg2 = (Dali::Vector2 *)jarg2;
4576   if (!arg2) {
4577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4578     return 0;
4579   }
4580   {
4581     try {
4582       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4583     } catch (std::out_of_range& e) {
4584       {
4585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (std::exception& e) {
4588       {
4589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (...) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4594       };
4595     }
4596   }
4597   jresult = result;
4598   return jresult;
4599 }
4600
4601
4602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4603   float jresult ;
4604   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4605   unsigned int arg2 ;
4606   float *result = 0 ;
4607
4608   arg1 = (Dali::Vector2 *)jarg1;
4609   arg2 = (unsigned int)jarg2;
4610   {
4611     try {
4612       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4613     } catch (std::out_of_range& e) {
4614       {
4615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (std::exception& e) {
4618       {
4619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4620       };
4621     } catch (...) {
4622       {
4623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4624       };
4625     }
4626   }
4627   jresult = *result;
4628   return jresult;
4629 }
4630
4631
4632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4633   float jresult ;
4634   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4635   float result;
4636
4637   arg1 = (Dali::Vector2 *)jarg1;
4638   {
4639     try {
4640       result = (float)((Dali::Vector2 const *)arg1)->Length();
4641     } catch (std::out_of_range& e) {
4642       {
4643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4644       };
4645     } catch (std::exception& e) {
4646       {
4647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4648       };
4649     } catch (...) {
4650       {
4651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4652       };
4653     }
4654   }
4655   jresult = result;
4656   return jresult;
4657 }
4658
4659
4660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4661   float jresult ;
4662   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4663   float result;
4664
4665   arg1 = (Dali::Vector2 *)jarg1;
4666   {
4667     try {
4668       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4669     } catch (std::out_of_range& e) {
4670       {
4671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (std::exception& e) {
4674       {
4675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683   jresult = result;
4684   return jresult;
4685 }
4686
4687
4688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4689   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4690
4691   arg1 = (Dali::Vector2 *)jarg1;
4692   {
4693     try {
4694       (arg1)->Normalize();
4695     } catch (std::out_of_range& e) {
4696       {
4697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4698       };
4699     } catch (std::exception& e) {
4700       {
4701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4702       };
4703     } catch (...) {
4704       {
4705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4706       };
4707     }
4708   }
4709 }
4710
4711
4712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4713   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4714   Dali::Vector2 *arg2 = 0 ;
4715   Dali::Vector2 *arg3 = 0 ;
4716
4717   arg1 = (Dali::Vector2 *)jarg1;
4718   arg2 = (Dali::Vector2 *)jarg2;
4719   if (!arg2) {
4720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4721     return ;
4722   }
4723   arg3 = (Dali::Vector2 *)jarg3;
4724   if (!arg3) {
4725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4726     return ;
4727   }
4728   {
4729     try {
4730       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4731     } catch (std::out_of_range& e) {
4732       {
4733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4734       };
4735     } catch (std::exception& e) {
4736       {
4737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4738       };
4739     } catch (...) {
4740       {
4741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4742       };
4743     }
4744   }
4745 }
4746
4747
4748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4749   void * jresult ;
4750   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4751   float *result = 0 ;
4752
4753   arg1 = (Dali::Vector2 *)jarg1;
4754   {
4755     try {
4756       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4757     } catch (std::out_of_range& e) {
4758       {
4759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4760       };
4761     } catch (std::exception& e) {
4762       {
4763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4764       };
4765     } catch (...) {
4766       {
4767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4768       };
4769     }
4770   }
4771   jresult = (void *)result;
4772   return jresult;
4773 }
4774
4775
4776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4777   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4778   float arg2 ;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (float)jarg2;
4782   if (arg1) (arg1)->x = arg2;
4783 }
4784
4785
4786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4787   float jresult ;
4788   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4789   float result;
4790
4791   arg1 = (Dali::Vector2 *)jarg1;
4792   result = (float) ((arg1)->x);
4793   jresult = result;
4794   return jresult;
4795 }
4796
4797
4798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4799   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4800   float arg2 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (float)jarg2;
4804   if (arg1) (arg1)->width = arg2;
4805 }
4806
4807
4808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4809   float jresult ;
4810   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4811   float result;
4812
4813   arg1 = (Dali::Vector2 *)jarg1;
4814   result = (float) ((arg1)->width);
4815   jresult = result;
4816   return jresult;
4817 }
4818
4819
4820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4821   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4822   float arg2 ;
4823
4824   arg1 = (Dali::Vector2 *)jarg1;
4825   arg2 = (float)jarg2;
4826   if (arg1) (arg1)->y = arg2;
4827 }
4828
4829
4830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4831   float jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   float result;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   result = (float) ((arg1)->y);
4837   jresult = result;
4838   return jresult;
4839 }
4840
4841
4842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845
4846   arg1 = (Dali::Vector2 *)jarg1;
4847   arg2 = (float)jarg2;
4848   if (arg1) (arg1)->height = arg2;
4849 }
4850
4851
4852 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4853   float jresult ;
4854   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4855   float result;
4856
4857   arg1 = (Dali::Vector2 *)jarg1;
4858   result = (float) ((arg1)->height);
4859   jresult = result;
4860   return jresult;
4861 }
4862
4863
4864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4865   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4866
4867   arg1 = (Dali::Vector2 *)jarg1;
4868   {
4869     try {
4870       delete arg1;
4871     } catch (std::out_of_range& e) {
4872       {
4873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4874       };
4875     } catch (std::exception& e) {
4876       {
4877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4878       };
4879     } catch (...) {
4880       {
4881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4882       };
4883     }
4884   }
4885 }
4886
4887
4888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4889   void * jresult ;
4890   Dali::Vector2 *arg1 = 0 ;
4891   Dali::Vector2 *arg2 = 0 ;
4892   Dali::Vector2 result;
4893
4894   arg1 = (Dali::Vector2 *)jarg1;
4895   if (!arg1) {
4896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4897     return 0;
4898   }
4899   arg2 = (Dali::Vector2 *)jarg2;
4900   if (!arg2) {
4901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4902     return 0;
4903   }
4904   {
4905     try {
4906       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4907     } catch (std::out_of_range& e) {
4908       {
4909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4910       };
4911     } catch (std::exception& e) {
4912       {
4913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4914       };
4915     } catch (...) {
4916       {
4917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4918       };
4919     }
4920   }
4921   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4922   return jresult;
4923 }
4924
4925
4926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4927   void * jresult ;
4928   Dali::Vector2 *arg1 = 0 ;
4929   Dali::Vector2 *arg2 = 0 ;
4930   Dali::Vector2 result;
4931
4932   arg1 = (Dali::Vector2 *)jarg1;
4933   if (!arg1) {
4934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4935     return 0;
4936   }
4937   arg2 = (Dali::Vector2 *)jarg2;
4938   if (!arg2) {
4939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4940     return 0;
4941   }
4942   {
4943     try {
4944       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4945     } catch (std::out_of_range& e) {
4946       {
4947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4948       };
4949     } catch (std::exception& e) {
4950       {
4951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4952       };
4953     } catch (...) {
4954       {
4955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4956       };
4957     }
4958   }
4959   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4960   return jresult;
4961 }
4962
4963
4964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4965   void * jresult ;
4966   Dali::Vector2 *arg1 = 0 ;
4967   float *arg2 = 0 ;
4968   float *arg3 = 0 ;
4969   float temp2 ;
4970   float temp3 ;
4971   Dali::Vector2 result;
4972
4973   arg1 = (Dali::Vector2 *)jarg1;
4974   if (!arg1) {
4975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4976     return 0;
4977   }
4978   temp2 = (float)jarg2;
4979   arg2 = &temp2;
4980   temp3 = (float)jarg3;
4981   arg3 = &temp3;
4982   {
4983     try {
4984       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4985     } catch (std::out_of_range& e) {
4986       {
4987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4988       };
4989     } catch (std::exception& e) {
4990       {
4991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (...) {
4994       {
4995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4996       };
4997     }
4998   }
4999   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5000   return jresult;
5001 }
5002
5003
5004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5005   void * jresult ;
5006   Dali::Vector3 *result = 0 ;
5007
5008   {
5009     try {
5010       result = (Dali::Vector3 *)new Dali::Vector3();
5011     } catch (std::out_of_range& e) {
5012       {
5013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (std::exception& e) {
5016       {
5017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025   jresult = (void *)result;
5026   return jresult;
5027 }
5028
5029
5030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5031   void * jresult ;
5032   float arg1 ;
5033   float arg2 ;
5034   float arg3 ;
5035   Dali::Vector3 *result = 0 ;
5036
5037   arg1 = (float)jarg1;
5038   arg2 = (float)jarg2;
5039   arg3 = (float)jarg3;
5040   {
5041     try {
5042       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5043     } catch (std::out_of_range& e) {
5044       {
5045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (std::exception& e) {
5048       {
5049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5050       };
5051     } catch (...) {
5052       {
5053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5054       };
5055     }
5056   }
5057   jresult = (void *)result;
5058   return jresult;
5059 }
5060
5061
5062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5063   void * jresult ;
5064   float *arg1 = (float *) 0 ;
5065   Dali::Vector3 *result = 0 ;
5066
5067   arg1 = jarg1;
5068   {
5069     try {
5070       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5071     } catch (std::out_of_range& e) {
5072       {
5073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5074       };
5075     } catch (std::exception& e) {
5076       {
5077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5078       };
5079     } catch (...) {
5080       {
5081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5082       };
5083     }
5084   }
5085   jresult = (void *)result;
5086
5087
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5093   void * jresult ;
5094   Dali::Vector2 *arg1 = 0 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (Dali::Vector2 *)jarg1;
5098   if (!arg1) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119   jresult = (void *)result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5125   void * jresult ;
5126   Dali::Vector4 *arg1 = 0 ;
5127   Dali::Vector3 *result = 0 ;
5128
5129   arg1 = (Dali::Vector4 *)jarg1;
5130   if (!arg1) {
5131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5132     return 0;
5133   }
5134   {
5135     try {
5136       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5137     } catch (std::out_of_range& e) {
5138       {
5139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5140       };
5141     } catch (std::exception& e) {
5142       {
5143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5144       };
5145     } catch (...) {
5146       {
5147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5148       };
5149     }
5150   }
5151   jresult = (void *)result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5157   void * jresult ;
5158   Dali::Vector3 *result = 0 ;
5159
5160   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5161   jresult = (void *)result;
5162   return jresult;
5163 }
5164
5165
5166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5167   void * jresult ;
5168   Dali::Vector3 *result = 0 ;
5169
5170   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5171   jresult = (void *)result;
5172   return jresult;
5173 }
5174
5175
5176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5177   void * jresult ;
5178   Dali::Vector3 *result = 0 ;
5179
5180   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5181   jresult = (void *)result;
5182   return jresult;
5183 }
5184
5185
5186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5187   void * jresult ;
5188   Dali::Vector3 *result = 0 ;
5189
5190   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5191   jresult = (void *)result;
5192   return jresult;
5193 }
5194
5195
5196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5197   void * jresult ;
5198   Dali::Vector3 *result = 0 ;
5199
5200   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5201   jresult = (void *)result;
5202   return jresult;
5203 }
5204
5205
5206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5207   void * jresult ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5211   jresult = (void *)result;
5212   return jresult;
5213 }
5214
5215
5216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5217   void * jresult ;
5218   Dali::Vector3 *result = 0 ;
5219
5220   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5221   jresult = (void *)result;
5222   return jresult;
5223 }
5224
5225
5226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5227   void * jresult ;
5228   Dali::Vector3 *result = 0 ;
5229
5230   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5231   jresult = (void *)result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5237   void * jresult ;
5238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5239   float *arg2 = (float *) 0 ;
5240   Dali::Vector3 *result = 0 ;
5241
5242   arg1 = (Dali::Vector3 *)jarg1;
5243   arg2 = jarg2;
5244   {
5245     try {
5246       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5247     } catch (std::out_of_range& e) {
5248       {
5249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5250       };
5251     } catch (std::exception& e) {
5252       {
5253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5258       };
5259     }
5260   }
5261   jresult = (void *)result;
5262
5263
5264   return jresult;
5265 }
5266
5267
5268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5269   void * jresult ;
5270   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5271   Dali::Vector2 *arg2 = 0 ;
5272   Dali::Vector3 *result = 0 ;
5273
5274   arg1 = (Dali::Vector3 *)jarg1;
5275   arg2 = (Dali::Vector2 *)jarg2;
5276   if (!arg2) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5278     return 0;
5279   }
5280   {
5281     try {
5282       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5283     } catch (std::out_of_range& e) {
5284       {
5285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5286       };
5287     } catch (std::exception& e) {
5288       {
5289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5290       };
5291     } catch (...) {
5292       {
5293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5294       };
5295     }
5296   }
5297   jresult = (void *)result;
5298   return jresult;
5299 }
5300
5301
5302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5303   void * jresult ;
5304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5305   Dali::Vector4 *arg2 = 0 ;
5306   Dali::Vector3 *result = 0 ;
5307
5308   arg1 = (Dali::Vector3 *)jarg1;
5309   arg2 = (Dali::Vector4 *)jarg2;
5310   if (!arg2) {
5311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5312     return 0;
5313   }
5314   {
5315     try {
5316       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (...) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5328       };
5329     }
5330   }
5331   jresult = (void *)result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5337   void * jresult ;
5338   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5339   Dali::Vector3 *arg2 = 0 ;
5340   Dali::Vector3 result;
5341
5342   arg1 = (Dali::Vector3 *)jarg1;
5343   arg2 = (Dali::Vector3 *)jarg2;
5344   if (!arg2) {
5345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5346     return 0;
5347   }
5348   {
5349     try {
5350       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5351     } catch (std::out_of_range& e) {
5352       {
5353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5354       };
5355     } catch (std::exception& e) {
5356       {
5357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5358       };
5359     } catch (...) {
5360       {
5361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5362       };
5363     }
5364   }
5365   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5366   return jresult;
5367 }
5368
5369
5370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5371   void * jresult ;
5372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5373   Dali::Vector3 *arg2 = 0 ;
5374   Dali::Vector3 *result = 0 ;
5375
5376   arg1 = (Dali::Vector3 *)jarg1;
5377   arg2 = (Dali::Vector3 *)jarg2;
5378   if (!arg2) {
5379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5380     return 0;
5381   }
5382   {
5383     try {
5384       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5385     } catch (std::out_of_range& e) {
5386       {
5387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5388       };
5389     } catch (std::exception& e) {
5390       {
5391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5392       };
5393     } catch (...) {
5394       {
5395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5396       };
5397     }
5398   }
5399   jresult = (void *)result;
5400   return jresult;
5401 }
5402
5403
5404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5405   void * jresult ;
5406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5407   Dali::Vector3 *arg2 = 0 ;
5408   Dali::Vector3 result;
5409
5410   arg1 = (Dali::Vector3 *)jarg1;
5411   arg2 = (Dali::Vector3 *)jarg2;
5412   if (!arg2) {
5413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5414     return 0;
5415   }
5416   {
5417     try {
5418       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5419     } catch (std::out_of_range& e) {
5420       {
5421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5422       };
5423     } catch (std::exception& e) {
5424       {
5425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5426       };
5427     } catch (...) {
5428       {
5429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5430       };
5431     }
5432   }
5433   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5434   return jresult;
5435 }
5436
5437
5438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5439   void * jresult ;
5440   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5441   Dali::Vector3 *arg2 = 0 ;
5442   Dali::Vector3 *result = 0 ;
5443
5444   arg1 = (Dali::Vector3 *)jarg1;
5445   arg2 = (Dali::Vector3 *)jarg2;
5446   if (!arg2) {
5447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5448     return 0;
5449   }
5450   {
5451     try {
5452       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5453     } catch (std::out_of_range& e) {
5454       {
5455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5456       };
5457     } catch (std::exception& e) {
5458       {
5459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5460       };
5461     } catch (...) {
5462       {
5463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5464       };
5465     }
5466   }
5467   jresult = (void *)result;
5468   return jresult;
5469 }
5470
5471
5472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5473   void * jresult ;
5474   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5475   Dali::Vector3 *arg2 = 0 ;
5476   Dali::Vector3 result;
5477
5478   arg1 = (Dali::Vector3 *)jarg1;
5479   arg2 = (Dali::Vector3 *)jarg2;
5480   if (!arg2) {
5481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5482     return 0;
5483   }
5484   {
5485     try {
5486       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5487     } catch (std::out_of_range& e) {
5488       {
5489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5490       };
5491     } catch (std::exception& e) {
5492       {
5493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5494       };
5495     } catch (...) {
5496       {
5497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5498       };
5499     }
5500   }
5501   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5502   return jresult;
5503 }
5504
5505
5506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5507   void * jresult ;
5508   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5509   float arg2 ;
5510   Dali::Vector3 result;
5511
5512   arg1 = (Dali::Vector3 *)jarg1;
5513   arg2 = (float)jarg2;
5514   {
5515     try {
5516       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5517     } catch (std::out_of_range& e) {
5518       {
5519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5520       };
5521     } catch (std::exception& e) {
5522       {
5523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5524       };
5525     } catch (...) {
5526       {
5527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5528       };
5529     }
5530   }
5531   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5537   void * jresult ;
5538   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5539   Dali::Vector3 *arg2 = 0 ;
5540   Dali::Vector3 *result = 0 ;
5541
5542   arg1 = (Dali::Vector3 *)jarg1;
5543   arg2 = (Dali::Vector3 *)jarg2;
5544   if (!arg2) {
5545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5546     return 0;
5547   }
5548   {
5549     try {
5550       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5551     } catch (std::out_of_range& e) {
5552       {
5553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (std::exception& e) {
5556       {
5557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5558       };
5559     } catch (...) {
5560       {
5561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5562       };
5563     }
5564   }
5565   jresult = (void *)result;
5566   return jresult;
5567 }
5568
5569
5570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5571   void * jresult ;
5572   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5573   float arg2 ;
5574   Dali::Vector3 *result = 0 ;
5575
5576   arg1 = (Dali::Vector3 *)jarg1;
5577   arg2 = (float)jarg2;
5578   {
5579     try {
5580       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5581     } catch (std::out_of_range& e) {
5582       {
5583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5584       };
5585     } catch (std::exception& e) {
5586       {
5587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5588       };
5589     } catch (...) {
5590       {
5591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5592       };
5593     }
5594   }
5595   jresult = (void *)result;
5596   return jresult;
5597 }
5598
5599
5600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5601   void * jresult ;
5602   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5603   Dali::Quaternion *arg2 = 0 ;
5604   Dali::Vector3 *result = 0 ;
5605
5606   arg1 = (Dali::Vector3 *)jarg1;
5607   arg2 = (Dali::Quaternion *)jarg2;
5608   if (!arg2) {
5609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5610     return 0;
5611   }
5612   {
5613     try {
5614       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5615     } catch (std::out_of_range& e) {
5616       {
5617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (std::exception& e) {
5620       {
5621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (...) {
5624       {
5625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5626       };
5627     }
5628   }
5629   jresult = (void *)result;
5630   return jresult;
5631 }
5632
5633
5634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5635   void * jresult ;
5636   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5637   Dali::Vector3 *arg2 = 0 ;
5638   Dali::Vector3 result;
5639
5640   arg1 = (Dali::Vector3 *)jarg1;
5641   arg2 = (Dali::Vector3 *)jarg2;
5642   if (!arg2) {
5643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5644     return 0;
5645   }
5646   {
5647     try {
5648       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5649     } catch (std::out_of_range& e) {
5650       {
5651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5652       };
5653     } catch (std::exception& e) {
5654       {
5655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5656       };
5657     } catch (...) {
5658       {
5659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5660       };
5661     }
5662   }
5663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5664   return jresult;
5665 }
5666
5667
5668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5669   void * jresult ;
5670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5671   float arg2 ;
5672   Dali::Vector3 result;
5673
5674   arg1 = (Dali::Vector3 *)jarg1;
5675   arg2 = (float)jarg2;
5676   {
5677     try {
5678       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5679     } catch (std::out_of_range& e) {
5680       {
5681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5682       };
5683     } catch (std::exception& e) {
5684       {
5685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5686       };
5687     } catch (...) {
5688       {
5689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5690       };
5691     }
5692   }
5693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5694   return jresult;
5695 }
5696
5697
5698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5699   void * jresult ;
5700   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5701   Dali::Vector3 *arg2 = 0 ;
5702   Dali::Vector3 *result = 0 ;
5703
5704   arg1 = (Dali::Vector3 *)jarg1;
5705   arg2 = (Dali::Vector3 *)jarg2;
5706   if (!arg2) {
5707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5708     return 0;
5709   }
5710   {
5711     try {
5712       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5713     } catch (std::out_of_range& e) {
5714       {
5715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5716       };
5717     } catch (std::exception& e) {
5718       {
5719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5720       };
5721     } catch (...) {
5722       {
5723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5724       };
5725     }
5726   }
5727   jresult = (void *)result;
5728   return jresult;
5729 }
5730
5731
5732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5733   void * jresult ;
5734   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5735   float arg2 ;
5736   Dali::Vector3 *result = 0 ;
5737
5738   arg1 = (Dali::Vector3 *)jarg1;
5739   arg2 = (float)jarg2;
5740   {
5741     try {
5742       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5743     } catch (std::out_of_range& e) {
5744       {
5745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (std::exception& e) {
5748       {
5749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5750       };
5751     } catch (...) {
5752       {
5753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5754       };
5755     }
5756   }
5757   jresult = (void *)result;
5758   return jresult;
5759 }
5760
5761
5762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5763   void * jresult ;
5764   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5765   Dali::Vector3 result;
5766
5767   arg1 = (Dali::Vector3 *)jarg1;
5768   {
5769     try {
5770       result = ((Dali::Vector3 const *)arg1)->operator -();
5771     } catch (std::out_of_range& e) {
5772       {
5773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5774       };
5775     } catch (std::exception& e) {
5776       {
5777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5778       };
5779     } catch (...) {
5780       {
5781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5782       };
5783     }
5784   }
5785   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5791   unsigned int jresult ;
5792   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5793   Dali::Vector3 *arg2 = 0 ;
5794   bool result;
5795
5796   arg1 = (Dali::Vector3 *)jarg1;
5797   arg2 = (Dali::Vector3 *)jarg2;
5798   if (!arg2) {
5799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5800     return 0;
5801   }
5802   {
5803     try {
5804       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5805     } catch (std::out_of_range& e) {
5806       {
5807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5808       };
5809     } catch (std::exception& e) {
5810       {
5811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5812       };
5813     } catch (...) {
5814       {
5815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5816       };
5817     }
5818   }
5819   jresult = result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5825   unsigned int jresult ;
5826   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5827   Dali::Vector3 *arg2 = 0 ;
5828   bool result;
5829
5830   arg1 = (Dali::Vector3 *)jarg1;
5831   arg2 = (Dali::Vector3 *)jarg2;
5832   if (!arg2) {
5833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5834     return 0;
5835   }
5836   {
5837     try {
5838       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5839     } catch (std::out_of_range& e) {
5840       {
5841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5842       };
5843     } catch (std::exception& e) {
5844       {
5845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5846       };
5847     } catch (...) {
5848       {
5849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5850       };
5851     }
5852   }
5853   jresult = result;
5854   return jresult;
5855 }
5856
5857
5858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5859   float jresult ;
5860   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5861   unsigned int arg2 ;
5862   float *result = 0 ;
5863
5864   arg1 = (Dali::Vector3 *)jarg1;
5865   arg2 = (unsigned int)jarg2;
5866   {
5867     try {
5868       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5869     } catch (std::out_of_range& e) {
5870       {
5871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5872       };
5873     } catch (std::exception& e) {
5874       {
5875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5876       };
5877     } catch (...) {
5878       {
5879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5880       };
5881     }
5882   }
5883   jresult = *result;
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5889   float jresult ;
5890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5891   Dali::Vector3 *arg2 = 0 ;
5892   float result;
5893
5894   arg1 = (Dali::Vector3 *)jarg1;
5895   arg2 = (Dali::Vector3 *)jarg2;
5896   if (!arg2) {
5897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5898     return 0;
5899   }
5900   {
5901     try {
5902       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5903     } catch (std::out_of_range& e) {
5904       {
5905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (std::exception& e) {
5908       {
5909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5910       };
5911     } catch (...) {
5912       {
5913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5914       };
5915     }
5916   }
5917   jresult = result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector3 *arg2 = 0 ;
5926   Dali::Vector3 result;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector3 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (...) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5948       };
5949     }
5950   }
5951   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5952   return jresult;
5953 }
5954
5955
5956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5957   float jresult ;
5958   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5959   float result;
5960
5961   arg1 = (Dali::Vector3 *)jarg1;
5962   {
5963     try {
5964       result = (float)((Dali::Vector3 const *)arg1)->Length();
5965     } catch (std::out_of_range& e) {
5966       {
5967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5968       };
5969     } catch (std::exception& e) {
5970       {
5971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5972       };
5973     } catch (...) {
5974       {
5975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5976       };
5977     }
5978   }
5979   jresult = result;
5980   return jresult;
5981 }
5982
5983
5984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5985   float jresult ;
5986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5987   float result;
5988
5989   arg1 = (Dali::Vector3 *)jarg1;
5990   {
5991     try {
5992       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5993     } catch (std::out_of_range& e) {
5994       {
5995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5996       };
5997     } catch (std::exception& e) {
5998       {
5999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6000       };
6001     } catch (...) {
6002       {
6003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6004       };
6005     }
6006   }
6007   jresult = result;
6008   return jresult;
6009 }
6010
6011
6012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6013   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6014
6015   arg1 = (Dali::Vector3 *)jarg1;
6016   {
6017     try {
6018       (arg1)->Normalize();
6019     } catch (std::out_of_range& e) {
6020       {
6021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6022       };
6023     } catch (std::exception& e) {
6024       {
6025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6030       };
6031     }
6032   }
6033 }
6034
6035
6036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6038   Dali::Vector3 *arg2 = 0 ;
6039   Dali::Vector3 *arg3 = 0 ;
6040
6041   arg1 = (Dali::Vector3 *)jarg1;
6042   arg2 = (Dali::Vector3 *)jarg2;
6043   if (!arg2) {
6044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6045     return ;
6046   }
6047   arg3 = (Dali::Vector3 *)jarg3;
6048   if (!arg3) {
6049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6050     return ;
6051   }
6052   {
6053     try {
6054       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6055     } catch (std::out_of_range& e) {
6056       {
6057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6058       };
6059     } catch (std::exception& e) {
6060       {
6061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6062       };
6063     } catch (...) {
6064       {
6065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6066       };
6067     }
6068   }
6069 }
6070
6071
6072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6073   void * jresult ;
6074   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6075   float *result = 0 ;
6076
6077   arg1 = (Dali::Vector3 *)jarg1;
6078   {
6079     try {
6080       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6081     } catch (std::out_of_range& e) {
6082       {
6083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (std::exception& e) {
6086       {
6087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (...) {
6090       {
6091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6092       };
6093     }
6094   }
6095   jresult = (void *)result;
6096   return jresult;
6097 }
6098
6099
6100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6101   void * jresult ;
6102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6103   Dali::Vector2 *result = 0 ;
6104
6105   arg1 = (Dali::Vector3 *)jarg1;
6106   {
6107     try {
6108       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6109     } catch (std::out_of_range& e) {
6110       {
6111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6112       };
6113     } catch (std::exception& e) {
6114       {
6115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6116       };
6117     } catch (...) {
6118       {
6119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6120       };
6121     }
6122   }
6123   jresult = (void *)result;
6124   return jresult;
6125 }
6126
6127
6128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6129   void * jresult ;
6130   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6131   Dali::Vector2 *result = 0 ;
6132
6133   arg1 = (Dali::Vector3 *)jarg1;
6134   {
6135     try {
6136       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (...) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6148       };
6149     }
6150   }
6151   jresult = (void *)result;
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6157   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6158   float arg2 ;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   if (arg1) (arg1)->x = arg2;
6163 }
6164
6165
6166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6167   float jresult ;
6168   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6169   float result;
6170
6171   arg1 = (Dali::Vector3 *)jarg1;
6172   result = (float) ((arg1)->x);
6173   jresult = result;
6174   return jresult;
6175 }
6176
6177
6178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6179   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6180   float arg2 ;
6181
6182   arg1 = (Dali::Vector3 *)jarg1;
6183   arg2 = (float)jarg2;
6184   if (arg1) (arg1)->width = arg2;
6185 }
6186
6187
6188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6189   float jresult ;
6190   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6191   float result;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   result = (float) ((arg1)->width);
6195   jresult = result;
6196   return jresult;
6197 }
6198
6199
6200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6201   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6202   float arg2 ;
6203
6204   arg1 = (Dali::Vector3 *)jarg1;
6205   arg2 = (float)jarg2;
6206   if (arg1) (arg1)->r = arg2;
6207 }
6208
6209
6210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6211   float jresult ;
6212   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6213   float result;
6214
6215   arg1 = (Dali::Vector3 *)jarg1;
6216   result = (float) ((arg1)->r);
6217   jresult = result;
6218   return jresult;
6219 }
6220
6221
6222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6223   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6224   float arg2 ;
6225
6226   arg1 = (Dali::Vector3 *)jarg1;
6227   arg2 = (float)jarg2;
6228   if (arg1) (arg1)->y = arg2;
6229 }
6230
6231
6232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6233   float jresult ;
6234   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6235   float result;
6236
6237   arg1 = (Dali::Vector3 *)jarg1;
6238   result = (float) ((arg1)->y);
6239   jresult = result;
6240   return jresult;
6241 }
6242
6243
6244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6245   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6246   float arg2 ;
6247
6248   arg1 = (Dali::Vector3 *)jarg1;
6249   arg2 = (float)jarg2;
6250   if (arg1) (arg1)->height = arg2;
6251 }
6252
6253
6254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6255   float jresult ;
6256   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6257   float result;
6258
6259   arg1 = (Dali::Vector3 *)jarg1;
6260   result = (float) ((arg1)->height);
6261   jresult = result;
6262   return jresult;
6263 }
6264
6265
6266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   float arg2 ;
6269
6270   arg1 = (Dali::Vector3 *)jarg1;
6271   arg2 = (float)jarg2;
6272   if (arg1) (arg1)->g = arg2;
6273 }
6274
6275
6276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6277   float jresult ;
6278   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6279   float result;
6280
6281   arg1 = (Dali::Vector3 *)jarg1;
6282   result = (float) ((arg1)->g);
6283   jresult = result;
6284   return jresult;
6285 }
6286
6287
6288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6289   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6290   float arg2 ;
6291
6292   arg1 = (Dali::Vector3 *)jarg1;
6293   arg2 = (float)jarg2;
6294   if (arg1) (arg1)->z = arg2;
6295 }
6296
6297
6298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6299   float jresult ;
6300   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6301   float result;
6302
6303   arg1 = (Dali::Vector3 *)jarg1;
6304   result = (float) ((arg1)->z);
6305   jresult = result;
6306   return jresult;
6307 }
6308
6309
6310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6311   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6312   float arg2 ;
6313
6314   arg1 = (Dali::Vector3 *)jarg1;
6315   arg2 = (float)jarg2;
6316   if (arg1) (arg1)->depth = arg2;
6317 }
6318
6319
6320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6321   float jresult ;
6322   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6323   float result;
6324
6325   arg1 = (Dali::Vector3 *)jarg1;
6326   result = (float) ((arg1)->depth);
6327   jresult = result;
6328   return jresult;
6329 }
6330
6331
6332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6334   float arg2 ;
6335
6336   arg1 = (Dali::Vector3 *)jarg1;
6337   arg2 = (float)jarg2;
6338   if (arg1) (arg1)->b = arg2;
6339 }
6340
6341
6342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6343   float jresult ;
6344   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6345   float result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   result = (float) ((arg1)->b);
6349   jresult = result;
6350   return jresult;
6351 }
6352
6353
6354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6355   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6356
6357   arg1 = (Dali::Vector3 *)jarg1;
6358   {
6359     try {
6360       delete arg1;
6361     } catch (std::out_of_range& e) {
6362       {
6363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6364       };
6365     } catch (std::exception& e) {
6366       {
6367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6368       };
6369     } catch (...) {
6370       {
6371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6372       };
6373     }
6374   }
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 result;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   if (!arg1) {
6386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6387     return 0;
6388   }
6389   arg2 = (Dali::Vector3 *)jarg2;
6390   if (!arg2) {
6391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6392     return 0;
6393   }
6394   {
6395     try {
6396       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6397     } catch (std::out_of_range& e) {
6398       {
6399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (std::exception& e) {
6402       {
6403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6412   return jresult;
6413 }
6414
6415
6416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6417   void * jresult ;
6418   Dali::Vector3 *arg1 = 0 ;
6419   Dali::Vector3 *arg2 = 0 ;
6420   Dali::Vector3 result;
6421
6422   arg1 = (Dali::Vector3 *)jarg1;
6423   if (!arg1) {
6424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6425     return 0;
6426   }
6427   arg2 = (Dali::Vector3 *)jarg2;
6428   if (!arg2) {
6429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6430     return 0;
6431   }
6432   {
6433     try {
6434       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6435     } catch (std::out_of_range& e) {
6436       {
6437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6438       };
6439     } catch (std::exception& e) {
6440       {
6441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6442       };
6443     } catch (...) {
6444       {
6445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6446       };
6447     }
6448   }
6449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6450   return jresult;
6451 }
6452
6453
6454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6455   void * jresult ;
6456   Dali::Vector3 *arg1 = 0 ;
6457   float *arg2 = 0 ;
6458   float *arg3 = 0 ;
6459   float temp2 ;
6460   float temp3 ;
6461   Dali::Vector3 result;
6462
6463   arg1 = (Dali::Vector3 *)jarg1;
6464   if (!arg1) {
6465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6466     return 0;
6467   }
6468   temp2 = (float)jarg2;
6469   arg2 = &temp2;
6470   temp3 = (float)jarg3;
6471   arg3 = &temp3;
6472   {
6473     try {
6474       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6475     } catch (std::out_of_range& e) {
6476       {
6477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6478       };
6479     } catch (std::exception& e) {
6480       {
6481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6482       };
6483     } catch (...) {
6484       {
6485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6486       };
6487     }
6488   }
6489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6490   return jresult;
6491 }
6492
6493
6494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6495   void * jresult ;
6496   Dali::Vector4 *result = 0 ;
6497
6498   {
6499     try {
6500       result = (Dali::Vector4 *)new Dali::Vector4();
6501     } catch (std::out_of_range& e) {
6502       {
6503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6504       };
6505     } catch (std::exception& e) {
6506       {
6507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6508       };
6509     } catch (...) {
6510       {
6511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6512       };
6513     }
6514   }
6515   jresult = (void *)result;
6516   return jresult;
6517 }
6518
6519
6520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6521   void * jresult ;
6522   float arg1 ;
6523   float arg2 ;
6524   float arg3 ;
6525   float arg4 ;
6526   Dali::Vector4 *result = 0 ;
6527
6528   arg1 = (float)jarg1;
6529   arg2 = (float)jarg2;
6530   arg3 = (float)jarg3;
6531   arg4 = (float)jarg4;
6532   {
6533     try {
6534       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6535     } catch (std::out_of_range& e) {
6536       {
6537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (std::exception& e) {
6540       {
6541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549   jresult = (void *)result;
6550   return jresult;
6551 }
6552
6553
6554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6555   void * jresult ;
6556   float *arg1 = (float *) 0 ;
6557   Dali::Vector4 *result = 0 ;
6558
6559   arg1 = jarg1;
6560   {
6561     try {
6562       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6563     } catch (std::out_of_range& e) {
6564       {
6565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6566       };
6567     } catch (std::exception& e) {
6568       {
6569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6570       };
6571     } catch (...) {
6572       {
6573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6574       };
6575     }
6576   }
6577   jresult = (void *)result;
6578
6579
6580   return jresult;
6581 }
6582
6583
6584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6585   void * jresult ;
6586   Dali::Vector2 *arg1 = 0 ;
6587   Dali::Vector4 *result = 0 ;
6588
6589   arg1 = (Dali::Vector2 *)jarg1;
6590   if (!arg1) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (...) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6608       };
6609     }
6610   }
6611   jresult = (void *)result;
6612   return jresult;
6613 }
6614
6615
6616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6617   void * jresult ;
6618   Dali::Vector3 *arg1 = 0 ;
6619   Dali::Vector4 *result = 0 ;
6620
6621   arg1 = (Dali::Vector3 *)jarg1;
6622   if (!arg1) {
6623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6624     return 0;
6625   }
6626   {
6627     try {
6628       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6629     } catch (std::out_of_range& e) {
6630       {
6631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6632       };
6633     } catch (std::exception& e) {
6634       {
6635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6636       };
6637     } catch (...) {
6638       {
6639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6640       };
6641     }
6642   }
6643   jresult = (void *)result;
6644   return jresult;
6645 }
6646
6647
6648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6649   void * jresult ;
6650   Dali::Vector4 *result = 0 ;
6651
6652   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6653   jresult = (void *)result;
6654   return jresult;
6655 }
6656
6657
6658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6659   void * jresult ;
6660   Dali::Vector4 *result = 0 ;
6661
6662   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6663   jresult = (void *)result;
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6669   void * jresult ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6673   jresult = (void *)result;
6674   return jresult;
6675 }
6676
6677
6678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6679   void * jresult ;
6680   Dali::Vector4 *result = 0 ;
6681
6682   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6683   jresult = (void *)result;
6684   return jresult;
6685 }
6686
6687
6688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6689   void * jresult ;
6690   Dali::Vector4 *result = 0 ;
6691
6692   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6693   jresult = (void *)result;
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6699   void * jresult ;
6700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6701   float *arg2 = (float *) 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector4 *)jarg1;
6705   arg2 = jarg2;
6706   {
6707     try {
6708       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6709     } catch (std::out_of_range& e) {
6710       {
6711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6712       };
6713     } catch (std::exception& e) {
6714       {
6715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (...) {
6718       {
6719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6720       };
6721     }
6722   }
6723   jresult = (void *)result;
6724
6725
6726   return jresult;
6727 }
6728
6729
6730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6731   void * jresult ;
6732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6733   Dali::Vector2 *arg2 = 0 ;
6734   Dali::Vector4 *result = 0 ;
6735
6736   arg1 = (Dali::Vector4 *)jarg1;
6737   arg2 = (Dali::Vector2 *)jarg2;
6738   if (!arg2) {
6739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6740     return 0;
6741   }
6742   {
6743     try {
6744       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6745     } catch (std::out_of_range& e) {
6746       {
6747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6748       };
6749     } catch (std::exception& e) {
6750       {
6751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6756       };
6757     }
6758   }
6759   jresult = (void *)result;
6760   return jresult;
6761 }
6762
6763
6764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6765   void * jresult ;
6766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6767   Dali::Vector3 *arg2 = 0 ;
6768   Dali::Vector4 *result = 0 ;
6769
6770   arg1 = (Dali::Vector4 *)jarg1;
6771   arg2 = (Dali::Vector3 *)jarg2;
6772   if (!arg2) {
6773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6774     return 0;
6775   }
6776   {
6777     try {
6778       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6779     } catch (std::out_of_range& e) {
6780       {
6781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6782       };
6783     } catch (std::exception& e) {
6784       {
6785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6786       };
6787     } catch (...) {
6788       {
6789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6790       };
6791     }
6792   }
6793   jresult = (void *)result;
6794   return jresult;
6795 }
6796
6797
6798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6799   void * jresult ;
6800   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6801   Dali::Vector4 *arg2 = 0 ;
6802   Dali::Vector4 result;
6803
6804   arg1 = (Dali::Vector4 *)jarg1;
6805   arg2 = (Dali::Vector4 *)jarg2;
6806   if (!arg2) {
6807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6808     return 0;
6809   }
6810   {
6811     try {
6812       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6813     } catch (std::out_of_range& e) {
6814       {
6815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6816       };
6817     } catch (std::exception& e) {
6818       {
6819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (...) {
6822       {
6823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6824       };
6825     }
6826   }
6827   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6833   void * jresult ;
6834   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6835   Dali::Vector4 *arg2 = 0 ;
6836   Dali::Vector4 *result = 0 ;
6837
6838   arg1 = (Dali::Vector4 *)jarg1;
6839   arg2 = (Dali::Vector4 *)jarg2;
6840   if (!arg2) {
6841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6842     return 0;
6843   }
6844   {
6845     try {
6846       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6847     } catch (std::out_of_range& e) {
6848       {
6849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6850       };
6851     } catch (std::exception& e) {
6852       {
6853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6854       };
6855     } catch (...) {
6856       {
6857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6858       };
6859     }
6860   }
6861   jresult = (void *)result;
6862   return jresult;
6863 }
6864
6865
6866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6867   void * jresult ;
6868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6869   Dali::Vector4 *arg2 = 0 ;
6870   Dali::Vector4 result;
6871
6872   arg1 = (Dali::Vector4 *)jarg1;
6873   arg2 = (Dali::Vector4 *)jarg2;
6874   if (!arg2) {
6875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6876     return 0;
6877   }
6878   {
6879     try {
6880       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6881     } catch (std::out_of_range& e) {
6882       {
6883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6884       };
6885     } catch (std::exception& e) {
6886       {
6887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (...) {
6890       {
6891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6892       };
6893     }
6894   }
6895   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6901   void * jresult ;
6902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6903   Dali::Vector4 *arg2 = 0 ;
6904   Dali::Vector4 *result = 0 ;
6905
6906   arg1 = (Dali::Vector4 *)jarg1;
6907   arg2 = (Dali::Vector4 *)jarg2;
6908   if (!arg2) {
6909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6910     return 0;
6911   }
6912   {
6913     try {
6914       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6915     } catch (std::out_of_range& e) {
6916       {
6917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6918       };
6919     } catch (std::exception& e) {
6920       {
6921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6922       };
6923     } catch (...) {
6924       {
6925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6926       };
6927     }
6928   }
6929   jresult = (void *)result;
6930   return jresult;
6931 }
6932
6933
6934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6935   void * jresult ;
6936   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6937   Dali::Vector4 *arg2 = 0 ;
6938   Dali::Vector4 result;
6939
6940   arg1 = (Dali::Vector4 *)jarg1;
6941   arg2 = (Dali::Vector4 *)jarg2;
6942   if (!arg2) {
6943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6944     return 0;
6945   }
6946   {
6947     try {
6948       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6949     } catch (std::out_of_range& e) {
6950       {
6951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6952       };
6953     } catch (std::exception& e) {
6954       {
6955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6956       };
6957     } catch (...) {
6958       {
6959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6960       };
6961     }
6962   }
6963   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6964   return jresult;
6965 }
6966
6967
6968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6969   void * jresult ;
6970   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6971   float arg2 ;
6972   Dali::Vector4 result;
6973
6974   arg1 = (Dali::Vector4 *)jarg1;
6975   arg2 = (float)jarg2;
6976   {
6977     try {
6978       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6979     } catch (std::out_of_range& e) {
6980       {
6981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6982       };
6983     } catch (std::exception& e) {
6984       {
6985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6986       };
6987     } catch (...) {
6988       {
6989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6990       };
6991     }
6992   }
6993   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6994   return jresult;
6995 }
6996
6997
6998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6999   void * jresult ;
7000   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7001   Dali::Vector4 *arg2 = 0 ;
7002   Dali::Vector4 *result = 0 ;
7003
7004   arg1 = (Dali::Vector4 *)jarg1;
7005   arg2 = (Dali::Vector4 *)jarg2;
7006   if (!arg2) {
7007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7008     return 0;
7009   }
7010   {
7011     try {
7012       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7013     } catch (std::out_of_range& e) {
7014       {
7015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7016       };
7017     } catch (std::exception& e) {
7018       {
7019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7020       };
7021     } catch (...) {
7022       {
7023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7024       };
7025     }
7026   }
7027   jresult = (void *)result;
7028   return jresult;
7029 }
7030
7031
7032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7033   void * jresult ;
7034   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7035   float arg2 ;
7036   Dali::Vector4 *result = 0 ;
7037
7038   arg1 = (Dali::Vector4 *)jarg1;
7039   arg2 = (float)jarg2;
7040   {
7041     try {
7042       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7043     } catch (std::out_of_range& e) {
7044       {
7045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7046       };
7047     } catch (std::exception& e) {
7048       {
7049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7050       };
7051     } catch (...) {
7052       {
7053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7054       };
7055     }
7056   }
7057   jresult = (void *)result;
7058   return jresult;
7059 }
7060
7061
7062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7063   void * jresult ;
7064   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7065   Dali::Vector4 *arg2 = 0 ;
7066   Dali::Vector4 result;
7067
7068   arg1 = (Dali::Vector4 *)jarg1;
7069   arg2 = (Dali::Vector4 *)jarg2;
7070   if (!arg2) {
7071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7072     return 0;
7073   }
7074   {
7075     try {
7076       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7077     } catch (std::out_of_range& e) {
7078       {
7079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7080       };
7081     } catch (std::exception& e) {
7082       {
7083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7084       };
7085     } catch (...) {
7086       {
7087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7088       };
7089     }
7090   }
7091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7092   return jresult;
7093 }
7094
7095
7096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7097   void * jresult ;
7098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7099   float arg2 ;
7100   Dali::Vector4 result;
7101
7102   arg1 = (Dali::Vector4 *)jarg1;
7103   arg2 = (float)jarg2;
7104   {
7105     try {
7106       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7107     } catch (std::out_of_range& e) {
7108       {
7109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7110       };
7111     } catch (std::exception& e) {
7112       {
7113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7114       };
7115     } catch (...) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7118       };
7119     }
7120   }
7121   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7122   return jresult;
7123 }
7124
7125
7126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7127   void * jresult ;
7128   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7129   Dali::Vector4 *arg2 = 0 ;
7130   Dali::Vector4 *result = 0 ;
7131
7132   arg1 = (Dali::Vector4 *)jarg1;
7133   arg2 = (Dali::Vector4 *)jarg2;
7134   if (!arg2) {
7135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7136     return 0;
7137   }
7138   {
7139     try {
7140       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7141     } catch (std::out_of_range& e) {
7142       {
7143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (std::exception& e) {
7146       {
7147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7148       };
7149     } catch (...) {
7150       {
7151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7152       };
7153     }
7154   }
7155   jresult = (void *)result;
7156   return jresult;
7157 }
7158
7159
7160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7161   void * jresult ;
7162   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7163   float arg2 ;
7164   Dali::Vector4 *result = 0 ;
7165
7166   arg1 = (Dali::Vector4 *)jarg1;
7167   arg2 = (float)jarg2;
7168   {
7169     try {
7170       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7171     } catch (std::out_of_range& e) {
7172       {
7173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (std::exception& e) {
7176       {
7177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7178       };
7179     } catch (...) {
7180       {
7181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7182       };
7183     }
7184   }
7185   jresult = (void *)result;
7186   return jresult;
7187 }
7188
7189
7190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7191   void * jresult ;
7192   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7193   Dali::Vector4 result;
7194
7195   arg1 = (Dali::Vector4 *)jarg1;
7196   {
7197     try {
7198       result = ((Dali::Vector4 const *)arg1)->operator -();
7199     } catch (std::out_of_range& e) {
7200       {
7201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7202       };
7203     } catch (std::exception& e) {
7204       {
7205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7206       };
7207     } catch (...) {
7208       {
7209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7210       };
7211     }
7212   }
7213   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7219   unsigned int jresult ;
7220   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7221   Dali::Vector4 *arg2 = 0 ;
7222   bool result;
7223
7224   arg1 = (Dali::Vector4 *)jarg1;
7225   arg2 = (Dali::Vector4 *)jarg2;
7226   if (!arg2) {
7227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7228     return 0;
7229   }
7230   {
7231     try {
7232       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7233     } catch (std::out_of_range& e) {
7234       {
7235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (std::exception& e) {
7238       {
7239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247   jresult = result;
7248   return jresult;
7249 }
7250
7251
7252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7253   unsigned int jresult ;
7254   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7255   Dali::Vector4 *arg2 = 0 ;
7256   bool result;
7257
7258   arg1 = (Dali::Vector4 *)jarg1;
7259   arg2 = (Dali::Vector4 *)jarg2;
7260   if (!arg2) {
7261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7262     return 0;
7263   }
7264   {
7265     try {
7266       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7267     } catch (std::out_of_range& e) {
7268       {
7269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (std::exception& e) {
7272       {
7273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7274       };
7275     } catch (...) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7278       };
7279     }
7280   }
7281   jresult = result;
7282   return jresult;
7283 }
7284
7285
7286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7287   float jresult ;
7288   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7289   unsigned int arg2 ;
7290   float *result = 0 ;
7291
7292   arg1 = (Dali::Vector4 *)jarg1;
7293   arg2 = (unsigned int)jarg2;
7294   {
7295     try {
7296       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7297     } catch (std::out_of_range& e) {
7298       {
7299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7300       };
7301     } catch (std::exception& e) {
7302       {
7303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (...) {
7306       {
7307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7308       };
7309     }
7310   }
7311   jresult = *result;
7312   return jresult;
7313 }
7314
7315
7316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7317   float jresult ;
7318   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7319   Dali::Vector3 *arg2 = 0 ;
7320   float result;
7321
7322   arg1 = (Dali::Vector4 *)jarg1;
7323   arg2 = (Dali::Vector3 *)jarg2;
7324   if (!arg2) {
7325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7326     return 0;
7327   }
7328   {
7329     try {
7330       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7331     } catch (std::out_of_range& e) {
7332       {
7333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7334       };
7335     } catch (std::exception& e) {
7336       {
7337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7338       };
7339     } catch (...) {
7340       {
7341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7342       };
7343     }
7344   }
7345   jresult = result;
7346   return jresult;
7347 }
7348
7349
7350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7351   float jresult ;
7352   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7353   Dali::Vector4 *arg2 = 0 ;
7354   float result;
7355
7356   arg1 = (Dali::Vector4 *)jarg1;
7357   arg2 = (Dali::Vector4 *)jarg2;
7358   if (!arg2) {
7359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7360     return 0;
7361   }
7362   {
7363     try {
7364       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7365     } catch (std::out_of_range& e) {
7366       {
7367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7368       };
7369     } catch (std::exception& e) {
7370       {
7371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7372       };
7373     } catch (...) {
7374       {
7375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7376       };
7377     }
7378   }
7379   jresult = result;
7380   return jresult;
7381 }
7382
7383
7384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7385   float jresult ;
7386   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7387   Dali::Vector4 *arg2 = 0 ;
7388   float result;
7389
7390   arg1 = (Dali::Vector4 *)jarg1;
7391   arg2 = (Dali::Vector4 *)jarg2;
7392   if (!arg2) {
7393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7394     return 0;
7395   }
7396   {
7397     try {
7398       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7399     } catch (std::out_of_range& e) {
7400       {
7401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7402       };
7403     } catch (std::exception& e) {
7404       {
7405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7406       };
7407     } catch (...) {
7408       {
7409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7410       };
7411     }
7412   }
7413   jresult = result;
7414   return jresult;
7415 }
7416
7417
7418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7419   void * jresult ;
7420   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7421   Dali::Vector4 *arg2 = 0 ;
7422   Dali::Vector4 result;
7423
7424   arg1 = (Dali::Vector4 *)jarg1;
7425   arg2 = (Dali::Vector4 *)jarg2;
7426   if (!arg2) {
7427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7428     return 0;
7429   }
7430   {
7431     try {
7432       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7433     } catch (std::out_of_range& e) {
7434       {
7435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (std::exception& e) {
7438       {
7439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7440       };
7441     } catch (...) {
7442       {
7443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7444       };
7445     }
7446   }
7447   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7453   float jresult ;
7454   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7455   float result;
7456
7457   arg1 = (Dali::Vector4 *)jarg1;
7458   {
7459     try {
7460       result = (float)((Dali::Vector4 const *)arg1)->Length();
7461     } catch (std::out_of_range& e) {
7462       {
7463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7464       };
7465     } catch (std::exception& e) {
7466       {
7467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7468       };
7469     } catch (...) {
7470       {
7471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7472       };
7473     }
7474   }
7475   jresult = result;
7476   return jresult;
7477 }
7478
7479
7480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7481   float jresult ;
7482   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7483   float result;
7484
7485   arg1 = (Dali::Vector4 *)jarg1;
7486   {
7487     try {
7488       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7489     } catch (std::out_of_range& e) {
7490       {
7491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7492       };
7493     } catch (std::exception& e) {
7494       {
7495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (...) {
7498       {
7499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7500       };
7501     }
7502   }
7503   jresult = result;
7504   return jresult;
7505 }
7506
7507
7508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7509   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7510
7511   arg1 = (Dali::Vector4 *)jarg1;
7512   {
7513     try {
7514       (arg1)->Normalize();
7515     } catch (std::out_of_range& e) {
7516       {
7517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7518       };
7519     } catch (std::exception& e) {
7520       {
7521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7522       };
7523     } catch (...) {
7524       {
7525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7526       };
7527     }
7528   }
7529 }
7530
7531
7532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7533   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7534   Dali::Vector4 *arg2 = 0 ;
7535   Dali::Vector4 *arg3 = 0 ;
7536
7537   arg1 = (Dali::Vector4 *)jarg1;
7538   arg2 = (Dali::Vector4 *)jarg2;
7539   if (!arg2) {
7540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7541     return ;
7542   }
7543   arg3 = (Dali::Vector4 *)jarg3;
7544   if (!arg3) {
7545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7546     return ;
7547   }
7548   {
7549     try {
7550       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7551     } catch (std::out_of_range& e) {
7552       {
7553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7554       };
7555     } catch (std::exception& e) {
7556       {
7557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7558       };
7559     } catch (...) {
7560       {
7561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7562       };
7563     }
7564   }
7565 }
7566
7567
7568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7569   void * jresult ;
7570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7571   float *result = 0 ;
7572
7573   arg1 = (Dali::Vector4 *)jarg1;
7574   {
7575     try {
7576       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7577     } catch (std::out_of_range& e) {
7578       {
7579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7580       };
7581     } catch (std::exception& e) {
7582       {
7583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (...) {
7586       {
7587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7588       };
7589     }
7590   }
7591   jresult = (void *)result;
7592   return jresult;
7593 }
7594
7595
7596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7598   float arg2 ;
7599
7600   arg1 = (Dali::Vector4 *)jarg1;
7601   arg2 = (float)jarg2;
7602   if (arg1) (arg1)->x = arg2;
7603 }
7604
7605
7606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7607   float jresult ;
7608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7609   float result;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   result = (float) ((arg1)->x);
7613   jresult = result;
7614   return jresult;
7615 }
7616
7617
7618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7620   float arg2 ;
7621
7622   arg1 = (Dali::Vector4 *)jarg1;
7623   arg2 = (float)jarg2;
7624   if (arg1) (arg1)->r = arg2;
7625 }
7626
7627
7628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7629   float jresult ;
7630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7631   float result;
7632
7633   arg1 = (Dali::Vector4 *)jarg1;
7634   result = (float) ((arg1)->r);
7635   jresult = result;
7636   return jresult;
7637 }
7638
7639
7640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7642   float arg2 ;
7643
7644   arg1 = (Dali::Vector4 *)jarg1;
7645   arg2 = (float)jarg2;
7646   if (arg1) (arg1)->s = arg2;
7647 }
7648
7649
7650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7651   float jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   float result;
7654
7655   arg1 = (Dali::Vector4 *)jarg1;
7656   result = (float) ((arg1)->s);
7657   jresult = result;
7658   return jresult;
7659 }
7660
7661
7662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7664   float arg2 ;
7665
7666   arg1 = (Dali::Vector4 *)jarg1;
7667   arg2 = (float)jarg2;
7668   if (arg1) (arg1)->y = arg2;
7669 }
7670
7671
7672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7673   float jresult ;
7674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7675   float result;
7676
7677   arg1 = (Dali::Vector4 *)jarg1;
7678   result = (float) ((arg1)->y);
7679   jresult = result;
7680   return jresult;
7681 }
7682
7683
7684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   float arg2 ;
7687
7688   arg1 = (Dali::Vector4 *)jarg1;
7689   arg2 = (float)jarg2;
7690   if (arg1) (arg1)->g = arg2;
7691 }
7692
7693
7694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7695   float jresult ;
7696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7697   float result;
7698
7699   arg1 = (Dali::Vector4 *)jarg1;
7700   result = (float) ((arg1)->g);
7701   jresult = result;
7702   return jresult;
7703 }
7704
7705
7706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7708   float arg2 ;
7709
7710   arg1 = (Dali::Vector4 *)jarg1;
7711   arg2 = (float)jarg2;
7712   if (arg1) (arg1)->t = arg2;
7713 }
7714
7715
7716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7717   float jresult ;
7718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7719   float result;
7720
7721   arg1 = (Dali::Vector4 *)jarg1;
7722   result = (float) ((arg1)->t);
7723   jresult = result;
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7730   float arg2 ;
7731
7732   arg1 = (Dali::Vector4 *)jarg1;
7733   arg2 = (float)jarg2;
7734   if (arg1) (arg1)->z = arg2;
7735 }
7736
7737
7738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7739   float jresult ;
7740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7741   float result;
7742
7743   arg1 = (Dali::Vector4 *)jarg1;
7744   result = (float) ((arg1)->z);
7745   jresult = result;
7746   return jresult;
7747 }
7748
7749
7750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7752   float arg2 ;
7753
7754   arg1 = (Dali::Vector4 *)jarg1;
7755   arg2 = (float)jarg2;
7756   if (arg1) (arg1)->b = arg2;
7757 }
7758
7759
7760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7761   float jresult ;
7762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7763   float result;
7764
7765   arg1 = (Dali::Vector4 *)jarg1;
7766   result = (float) ((arg1)->b);
7767   jresult = result;
7768   return jresult;
7769 }
7770
7771
7772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7774   float arg2 ;
7775
7776   arg1 = (Dali::Vector4 *)jarg1;
7777   arg2 = (float)jarg2;
7778   if (arg1) (arg1)->p = arg2;
7779 }
7780
7781
7782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7783   float jresult ;
7784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7785   float result;
7786
7787   arg1 = (Dali::Vector4 *)jarg1;
7788   result = (float) ((arg1)->p);
7789   jresult = result;
7790   return jresult;
7791 }
7792
7793
7794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7796   float arg2 ;
7797
7798   arg1 = (Dali::Vector4 *)jarg1;
7799   arg2 = (float)jarg2;
7800   if (arg1) (arg1)->w = arg2;
7801 }
7802
7803
7804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7805   float jresult ;
7806   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7807   float result;
7808
7809   arg1 = (Dali::Vector4 *)jarg1;
7810   result = (float) ((arg1)->w);
7811   jresult = result;
7812   return jresult;
7813 }
7814
7815
7816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7817   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7818   float arg2 ;
7819
7820   arg1 = (Dali::Vector4 *)jarg1;
7821   arg2 = (float)jarg2;
7822   if (arg1) (arg1)->a = arg2;
7823 }
7824
7825
7826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7827   float jresult ;
7828   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7829   float result;
7830
7831   arg1 = (Dali::Vector4 *)jarg1;
7832   result = (float) ((arg1)->a);
7833   jresult = result;
7834   return jresult;
7835 }
7836
7837
7838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7839   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7840   float arg2 ;
7841
7842   arg1 = (Dali::Vector4 *)jarg1;
7843   arg2 = (float)jarg2;
7844   if (arg1) (arg1)->q = arg2;
7845 }
7846
7847
7848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7849   float jresult ;
7850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7851   float result;
7852
7853   arg1 = (Dali::Vector4 *)jarg1;
7854   result = (float) ((arg1)->q);
7855   jresult = result;
7856   return jresult;
7857 }
7858
7859
7860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7861   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7862
7863   arg1 = (Dali::Vector4 *)jarg1;
7864   {
7865     try {
7866       delete arg1;
7867     } catch (std::out_of_range& e) {
7868       {
7869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7870       };
7871     } catch (std::exception& e) {
7872       {
7873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7874       };
7875     } catch (...) {
7876       {
7877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7878       };
7879     }
7880   }
7881 }
7882
7883
7884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7885   void * jresult ;
7886   Dali::Vector4 *arg1 = 0 ;
7887   Dali::Vector4 *arg2 = 0 ;
7888   Dali::Vector4 result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   if (!arg1) {
7892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7893     return 0;
7894   }
7895   arg2 = (Dali::Vector4 *)jarg2;
7896   if (!arg2) {
7897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7898     return 0;
7899   }
7900   {
7901     try {
7902       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7903     } catch (std::out_of_range& e) {
7904       {
7905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7906       };
7907     } catch (std::exception& e) {
7908       {
7909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7910       };
7911     } catch (...) {
7912       {
7913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7914       };
7915     }
7916   }
7917   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7918   return jresult;
7919 }
7920
7921
7922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7923   void * jresult ;
7924   Dali::Vector4 *arg1 = 0 ;
7925   Dali::Vector4 *arg2 = 0 ;
7926   Dali::Vector4 result;
7927
7928   arg1 = (Dali::Vector4 *)jarg1;
7929   if (!arg1) {
7930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7931     return 0;
7932   }
7933   arg2 = (Dali::Vector4 *)jarg2;
7934   if (!arg2) {
7935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7936     return 0;
7937   }
7938   {
7939     try {
7940       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7941     } catch (std::out_of_range& e) {
7942       {
7943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7944       };
7945     } catch (std::exception& e) {
7946       {
7947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7948       };
7949     } catch (...) {
7950       {
7951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7952       };
7953     }
7954   }
7955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7956   return jresult;
7957 }
7958
7959
7960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7961   void * jresult ;
7962   Dali::Vector4 *arg1 = 0 ;
7963   float *arg2 = 0 ;
7964   float *arg3 = 0 ;
7965   float temp2 ;
7966   float temp3 ;
7967   Dali::Vector4 result;
7968
7969   arg1 = (Dali::Vector4 *)jarg1;
7970   if (!arg1) {
7971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7972     return 0;
7973   }
7974   temp2 = (float)jarg2;
7975   arg2 = &temp2;
7976   temp3 = (float)jarg3;
7977   arg3 = &temp3;
7978   {
7979     try {
7980       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7981     } catch (std::out_of_range& e) {
7982       {
7983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7984       };
7985     } catch (std::exception& e) {
7986       {
7987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7988       };
7989     } catch (...) {
7990       {
7991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7992       };
7993     }
7994   }
7995   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7996   return jresult;
7997 }
7998
7999
8000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8001   void * jresult ;
8002   Dali::Uint16Pair *result = 0 ;
8003
8004   {
8005     try {
8006       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8007     } catch (std::out_of_range& e) {
8008       {
8009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8010       };
8011     } catch (std::exception& e) {
8012       {
8013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8014       };
8015     } catch (...) {
8016       {
8017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8018       };
8019     }
8020   }
8021   jresult = (void *)result;
8022   return jresult;
8023 }
8024
8025
8026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8027   void * jresult ;
8028   uint32_t arg1 ;
8029   uint32_t arg2 ;
8030   Dali::Uint16Pair *result = 0 ;
8031
8032   arg1 = (uint32_t)jarg1;
8033   arg2 = (uint32_t)jarg2;
8034   {
8035     try {
8036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8037     } catch (std::out_of_range& e) {
8038       {
8039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (std::exception& e) {
8042       {
8043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051   jresult = (void *)result;
8052   return jresult;
8053 }
8054
8055
8056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8057   void * jresult ;
8058   Dali::Uint16Pair *arg1 = 0 ;
8059   Dali::Uint16Pair *result = 0 ;
8060
8061   arg1 = (Dali::Uint16Pair *)jarg1;
8062   if (!arg1) {
8063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8064     return 0;
8065   }
8066   {
8067     try {
8068       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8069     } catch (std::out_of_range& e) {
8070       {
8071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8072       };
8073     } catch (std::exception& e) {
8074       {
8075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8076       };
8077     } catch (...) {
8078       {
8079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8080       };
8081     }
8082   }
8083   jresult = (void *)result;
8084   return jresult;
8085 }
8086
8087
8088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8089   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8090   uint16_t arg2 ;
8091
8092   arg1 = (Dali::Uint16Pair *)jarg1;
8093   arg2 = (uint16_t)jarg2;
8094   {
8095     try {
8096       (arg1)->SetWidth(arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8104       };
8105     } catch (...) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8108       };
8109     }
8110   }
8111 }
8112
8113
8114 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8115   unsigned short jresult ;
8116   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8117   uint16_t result;
8118
8119   arg1 = (Dali::Uint16Pair *)jarg1;
8120   {
8121     try {
8122       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8123     } catch (std::out_of_range& e) {
8124       {
8125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8126       };
8127     } catch (std::exception& e) {
8128       {
8129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8130       };
8131     } catch (...) {
8132       {
8133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8134       };
8135     }
8136   }
8137   jresult = result;
8138   return jresult;
8139 }
8140
8141
8142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8143   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8144   uint16_t arg2 ;
8145
8146   arg1 = (Dali::Uint16Pair *)jarg1;
8147   arg2 = (uint16_t)jarg2;
8148   {
8149     try {
8150       (arg1)->SetHeight(arg2);
8151     } catch (std::out_of_range& e) {
8152       {
8153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8154       };
8155     } catch (std::exception& e) {
8156       {
8157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8158       };
8159     } catch (...) {
8160       {
8161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8162       };
8163     }
8164   }
8165 }
8166
8167
8168 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8169   unsigned short jresult ;
8170   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8171   uint16_t result;
8172
8173   arg1 = (Dali::Uint16Pair *)jarg1;
8174   {
8175     try {
8176       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8177     } catch (std::out_of_range& e) {
8178       {
8179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8180       };
8181     } catch (std::exception& e) {
8182       {
8183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (...) {
8186       {
8187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8188       };
8189     }
8190   }
8191   jresult = result;
8192   return jresult;
8193 }
8194
8195
8196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8197   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8198   uint16_t arg2 ;
8199
8200   arg1 = (Dali::Uint16Pair *)jarg1;
8201   arg2 = (uint16_t)jarg2;
8202   {
8203     try {
8204       (arg1)->SetX(arg2);
8205     } catch (std::out_of_range& e) {
8206       {
8207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8208       };
8209     } catch (std::exception& e) {
8210       {
8211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8212       };
8213     } catch (...) {
8214       {
8215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8216       };
8217     }
8218   }
8219 }
8220
8221
8222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8223   unsigned short jresult ;
8224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8225   uint16_t result;
8226
8227   arg1 = (Dali::Uint16Pair *)jarg1;
8228   {
8229     try {
8230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8231     } catch (std::out_of_range& e) {
8232       {
8233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8234       };
8235     } catch (std::exception& e) {
8236       {
8237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8238       };
8239     } catch (...) {
8240       {
8241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8242       };
8243     }
8244   }
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8251   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8252   uint16_t arg2 ;
8253
8254   arg1 = (Dali::Uint16Pair *)jarg1;
8255   arg2 = (uint16_t)jarg2;
8256   {
8257     try {
8258       (arg1)->SetY(arg2);
8259     } catch (std::out_of_range& e) {
8260       {
8261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8262       };
8263     } catch (std::exception& e) {
8264       {
8265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8266       };
8267     } catch (...) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8270       };
8271     }
8272   }
8273 }
8274
8275
8276 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8277   unsigned short jresult ;
8278   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8279   uint16_t result;
8280
8281   arg1 = (Dali::Uint16Pair *)jarg1;
8282   {
8283     try {
8284       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8285     } catch (std::out_of_range& e) {
8286       {
8287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8288       };
8289     } catch (std::exception& e) {
8290       {
8291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8292       };
8293     } catch (...) {
8294       {
8295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8296       };
8297     }
8298   }
8299   jresult = result;
8300   return jresult;
8301 }
8302
8303
8304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8305   void * jresult ;
8306   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8307   Dali::Uint16Pair *arg2 = 0 ;
8308   Dali::Uint16Pair *result = 0 ;
8309
8310   arg1 = (Dali::Uint16Pair *)jarg1;
8311   arg2 = (Dali::Uint16Pair *)jarg2;
8312   if (!arg2) {
8313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8314     return 0;
8315   }
8316   {
8317     try {
8318       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8319     } catch (std::out_of_range& e) {
8320       {
8321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8322       };
8323     } catch (std::exception& e) {
8324       {
8325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8326       };
8327     } catch (...) {
8328       {
8329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8330       };
8331     }
8332   }
8333   jresult = (void *)result;
8334   return jresult;
8335 }
8336
8337
8338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8339   unsigned int jresult ;
8340   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8341   Dali::Uint16Pair *arg2 = 0 ;
8342   bool result;
8343
8344   arg1 = (Dali::Uint16Pair *)jarg1;
8345   arg2 = (Dali::Uint16Pair *)jarg2;
8346   if (!arg2) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8353     } catch (std::out_of_range& e) {
8354       {
8355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8356       };
8357     } catch (std::exception& e) {
8358       {
8359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8360       };
8361     } catch (...) {
8362       {
8363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8364       };
8365     }
8366   }
8367   jresult = result;
8368   return jresult;
8369 }
8370
8371
8372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8373   unsigned int jresult ;
8374   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8375   Dali::Uint16Pair *arg2 = 0 ;
8376   bool result;
8377
8378   arg1 = (Dali::Uint16Pair *)jarg1;
8379   arg2 = (Dali::Uint16Pair *)jarg2;
8380   if (!arg2) {
8381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8382     return 0;
8383   }
8384   {
8385     try {
8386       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8387     } catch (std::out_of_range& e) {
8388       {
8389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8390       };
8391     } catch (std::exception& e) {
8392       {
8393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8394       };
8395     } catch (...) {
8396       {
8397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8398       };
8399     }
8400   }
8401   jresult = result;
8402   return jresult;
8403 }
8404
8405
8406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8407   unsigned int jresult ;
8408   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8409   Dali::Uint16Pair *arg2 = 0 ;
8410   bool result;
8411
8412   arg1 = (Dali::Uint16Pair *)jarg1;
8413   arg2 = (Dali::Uint16Pair *)jarg2;
8414   if (!arg2) {
8415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8416     return 0;
8417   }
8418   {
8419     try {
8420       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8421     } catch (std::out_of_range& e) {
8422       {
8423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8424       };
8425     } catch (std::exception& e) {
8426       {
8427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8428       };
8429     } catch (...) {
8430       {
8431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8432       };
8433     }
8434   }
8435   jresult = result;
8436   return jresult;
8437 }
8438
8439
8440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8441   unsigned int jresult ;
8442   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8443   Dali::Uint16Pair *arg2 = 0 ;
8444   bool result;
8445
8446   arg1 = (Dali::Uint16Pair *)jarg1;
8447   arg2 = (Dali::Uint16Pair *)jarg2;
8448   if (!arg2) {
8449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8450     return 0;
8451   }
8452   {
8453     try {
8454       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8455     } catch (std::out_of_range& e) {
8456       {
8457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8458       };
8459     } catch (std::exception& e) {
8460       {
8461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8462       };
8463     } catch (...) {
8464       {
8465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8466       };
8467     }
8468   }
8469   jresult = result;
8470   return jresult;
8471 }
8472
8473
8474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8476
8477   arg1 = (Dali::Uint16Pair *)jarg1;
8478   {
8479     try {
8480       delete arg1;
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (...) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8492       };
8493     }
8494   }
8495 }
8496
8497
8498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8499   void * jresult ;
8500   Dali::Degree *result = 0 ;
8501
8502   {
8503     try {
8504       result = (Dali::Degree *)new Dali::Degree();
8505     } catch (std::out_of_range& e) {
8506       {
8507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8508       };
8509     } catch (std::exception& e) {
8510       {
8511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8512       };
8513     } catch (...) {
8514       {
8515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8516       };
8517     }
8518   }
8519   jresult = (void *)result;
8520   return jresult;
8521 }
8522
8523
8524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8525   void * jresult ;
8526   float arg1 ;
8527   Dali::Degree *result = 0 ;
8528
8529   arg1 = (float)jarg1;
8530   {
8531     try {
8532       result = (Dali::Degree *)new Dali::Degree(arg1);
8533     } catch (std::out_of_range& e) {
8534       {
8535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8536       };
8537     } catch (std::exception& e) {
8538       {
8539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8540       };
8541     } catch (...) {
8542       {
8543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8544       };
8545     }
8546   }
8547   jresult = (void *)result;
8548   return jresult;
8549 }
8550
8551
8552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8553   void * jresult ;
8554   Dali::Radian arg1 ;
8555   Dali::Radian *argp1 ;
8556   Dali::Degree *result = 0 ;
8557
8558   argp1 = (Dali::Radian *)jarg1;
8559   if (!argp1) {
8560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8561     return 0;
8562   }
8563   arg1 = *argp1;
8564   {
8565     try {
8566       result = (Dali::Degree *)new Dali::Degree(arg1);
8567     } catch (std::out_of_range& e) {
8568       {
8569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8570       };
8571     } catch (std::exception& e) {
8572       {
8573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8574       };
8575     } catch (...) {
8576       {
8577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8578       };
8579     }
8580   }
8581   jresult = (void *)result;
8582   return jresult;
8583 }
8584
8585
8586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8587   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8588   float arg2 ;
8589
8590   arg1 = (Dali::Degree *)jarg1;
8591   arg2 = (float)jarg2;
8592   if (arg1) (arg1)->degree = arg2;
8593 }
8594
8595
8596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8597   float jresult ;
8598   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8599   float result;
8600
8601   arg1 = (Dali::Degree *)jarg1;
8602   result = (float) ((arg1)->degree);
8603   jresult = result;
8604   return jresult;
8605 }
8606
8607
8608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8609   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8610
8611   arg1 = (Dali::Degree *)jarg1;
8612   {
8613     try {
8614       delete arg1;
8615     } catch (std::out_of_range& e) {
8616       {
8617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8618       };
8619     } catch (std::exception& e) {
8620       {
8621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8622       };
8623     } catch (...) {
8624       {
8625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8626       };
8627     }
8628   }
8629 }
8630
8631
8632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8633   void * jresult ;
8634   Dali::Radian *result = 0 ;
8635
8636   result = (Dali::Radian *)&Dali::ANGLE_360;
8637   jresult = (void *)result;
8638   return jresult;
8639 }
8640
8641
8642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8643   void * jresult ;
8644   Dali::Radian *result = 0 ;
8645
8646   result = (Dali::Radian *)&Dali::ANGLE_315;
8647   jresult = (void *)result;
8648   return jresult;
8649 }
8650
8651
8652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8653   void * jresult ;
8654   Dali::Radian *result = 0 ;
8655
8656   result = (Dali::Radian *)&Dali::ANGLE_270;
8657   jresult = (void *)result;
8658   return jresult;
8659 }
8660
8661
8662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8663   void * jresult ;
8664   Dali::Radian *result = 0 ;
8665
8666   result = (Dali::Radian *)&Dali::ANGLE_225;
8667   jresult = (void *)result;
8668   return jresult;
8669 }
8670
8671
8672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8673   void * jresult ;
8674   Dali::Radian *result = 0 ;
8675
8676   result = (Dali::Radian *)&Dali::ANGLE_180;
8677   jresult = (void *)result;
8678   return jresult;
8679 }
8680
8681
8682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8683   void * jresult ;
8684   Dali::Radian *result = 0 ;
8685
8686   result = (Dali::Radian *)&Dali::ANGLE_135;
8687   jresult = (void *)result;
8688   return jresult;
8689 }
8690
8691
8692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8693   void * jresult ;
8694   Dali::Radian *result = 0 ;
8695
8696   result = (Dali::Radian *)&Dali::ANGLE_120;
8697   jresult = (void *)result;
8698   return jresult;
8699 }
8700
8701
8702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8703   void * jresult ;
8704   Dali::Radian *result = 0 ;
8705
8706   result = (Dali::Radian *)&Dali::ANGLE_90;
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8713   void * jresult ;
8714   Dali::Radian *result = 0 ;
8715
8716   result = (Dali::Radian *)&Dali::ANGLE_60;
8717   jresult = (void *)result;
8718   return jresult;
8719 }
8720
8721
8722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8723   void * jresult ;
8724   Dali::Radian *result = 0 ;
8725
8726   result = (Dali::Radian *)&Dali::ANGLE_45;
8727   jresult = (void *)result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8733   void * jresult ;
8734   Dali::Radian *result = 0 ;
8735
8736   result = (Dali::Radian *)&Dali::ANGLE_30;
8737   jresult = (void *)result;
8738   return jresult;
8739 }
8740
8741
8742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8743   void * jresult ;
8744   Dali::Radian *result = 0 ;
8745
8746   result = (Dali::Radian *)&Dali::ANGLE_0;
8747   jresult = (void *)result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8753   unsigned int jresult ;
8754   Dali::Degree *arg1 = 0 ;
8755   Dali::Degree *arg2 = 0 ;
8756   bool result;
8757
8758   arg1 = (Dali::Degree *)jarg1;
8759   if (!arg1) {
8760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8761     return 0;
8762   }
8763   arg2 = (Dali::Degree *)jarg2;
8764   if (!arg2) {
8765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8766     return 0;
8767   }
8768   {
8769     try {
8770       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8771     } catch (std::out_of_range& e) {
8772       {
8773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8774       };
8775     } catch (std::exception& e) {
8776       {
8777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8778       };
8779     } catch (...) {
8780       {
8781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8782       };
8783     }
8784   }
8785   jresult = result;
8786   return jresult;
8787 }
8788
8789
8790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8791   unsigned int jresult ;
8792   Dali::Degree *arg1 = 0 ;
8793   Dali::Degree *arg2 = 0 ;
8794   bool result;
8795
8796   arg1 = (Dali::Degree *)jarg1;
8797   if (!arg1) {
8798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8799     return 0;
8800   }
8801   arg2 = (Dali::Degree *)jarg2;
8802   if (!arg2) {
8803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8804     return 0;
8805   }
8806   {
8807     try {
8808       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8809     } catch (std::out_of_range& e) {
8810       {
8811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8812       };
8813     } catch (std::exception& e) {
8814       {
8815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8820       };
8821     }
8822   }
8823   jresult = result;
8824   return jresult;
8825 }
8826
8827
8828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8829   void * jresult ;
8830   Dali::Degree arg1 ;
8831   float arg2 ;
8832   float arg3 ;
8833   Dali::Degree *argp1 ;
8834   Dali::Degree result;
8835
8836   argp1 = (Dali::Degree *)jarg1;
8837   if (!argp1) {
8838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8839     return 0;
8840   }
8841   arg1 = *argp1;
8842   arg2 = (float)jarg2;
8843   arg3 = (float)jarg3;
8844   {
8845     try {
8846       result = Dali::Clamp(arg1,arg2,arg3);
8847     } catch (std::out_of_range& e) {
8848       {
8849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8850       };
8851     } catch (std::exception& e) {
8852       {
8853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8854       };
8855     } catch (...) {
8856       {
8857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8858       };
8859     }
8860   }
8861   jresult = new Dali::Degree((const Dali::Degree &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8867   void * jresult ;
8868   Dali::Radian *result = 0 ;
8869
8870   {
8871     try {
8872       result = (Dali::Radian *)new Dali::Radian();
8873     } catch (std::out_of_range& e) {
8874       {
8875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (std::exception& e) {
8878       {
8879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8880       };
8881     } catch (...) {
8882       {
8883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8884       };
8885     }
8886   }
8887   jresult = (void *)result;
8888   return jresult;
8889 }
8890
8891
8892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8893   void * jresult ;
8894   float arg1 ;
8895   Dali::Radian *result = 0 ;
8896
8897   arg1 = (float)jarg1;
8898   {
8899     try {
8900       result = (Dali::Radian *)new Dali::Radian(arg1);
8901     } catch (std::out_of_range& e) {
8902       {
8903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8904       };
8905     } catch (std::exception& e) {
8906       {
8907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8908       };
8909     } catch (...) {
8910       {
8911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8912       };
8913     }
8914   }
8915   jresult = (void *)result;
8916   return jresult;
8917 }
8918
8919
8920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8921   void * jresult ;
8922   Dali::Degree arg1 ;
8923   Dali::Degree *argp1 ;
8924   Dali::Radian *result = 0 ;
8925
8926   argp1 = (Dali::Degree *)jarg1;
8927   if (!argp1) {
8928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8929     return 0;
8930   }
8931   arg1 = *argp1;
8932   {
8933     try {
8934       result = (Dali::Radian *)new Dali::Radian(arg1);
8935     } catch (std::out_of_range& e) {
8936       {
8937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8938       };
8939     } catch (std::exception& e) {
8940       {
8941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8942       };
8943     } catch (...) {
8944       {
8945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8946       };
8947     }
8948   }
8949   jresult = (void *)result;
8950   return jresult;
8951 }
8952
8953
8954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8955   void * jresult ;
8956   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8957   float arg2 ;
8958   Dali::Radian *result = 0 ;
8959
8960   arg1 = (Dali::Radian *)jarg1;
8961   arg2 = (float)jarg2;
8962   {
8963     try {
8964       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (...) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8976       };
8977     }
8978   }
8979   jresult = (void *)result;
8980   return jresult;
8981 }
8982
8983
8984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8985   void * jresult ;
8986   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8987   Dali::Degree arg2 ;
8988   Dali::Degree *argp2 ;
8989   Dali::Radian *result = 0 ;
8990
8991   arg1 = (Dali::Radian *)jarg1;
8992   argp2 = (Dali::Degree *)jarg2;
8993   if (!argp2) {
8994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8995     return 0;
8996   }
8997   arg2 = *argp2;
8998   {
8999     try {
9000       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9001     } catch (std::out_of_range& e) {
9002       {
9003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (std::exception& e) {
9006       {
9007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9008       };
9009     } catch (...) {
9010       {
9011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9012       };
9013     }
9014   }
9015   jresult = (void *)result;
9016   return jresult;
9017 }
9018
9019
9020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9021   float jresult ;
9022   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9023   float result;
9024
9025   arg1 = (Dali::Radian *)jarg1;
9026   {
9027     try {
9028       result = (float)((Dali::Radian const *)arg1)->operator float();
9029     } catch (std::out_of_range& e) {
9030       {
9031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9032       };
9033     } catch (std::exception& e) {
9034       {
9035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9036       };
9037     } catch (...) {
9038       {
9039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9040       };
9041     }
9042   }
9043   jresult = result;
9044   return jresult;
9045 }
9046
9047
9048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9050   float arg2 ;
9051
9052   arg1 = (Dali::Radian *)jarg1;
9053   arg2 = (float)jarg2;
9054   if (arg1) (arg1)->radian = arg2;
9055 }
9056
9057
9058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9059   float jresult ;
9060   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9061   float result;
9062
9063   arg1 = (Dali::Radian *)jarg1;
9064   result = (float) ((arg1)->radian);
9065   jresult = result;
9066   return jresult;
9067 }
9068
9069
9070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9071   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9072
9073   arg1 = (Dali::Radian *)jarg1;
9074   {
9075     try {
9076       delete arg1;
9077     } catch (std::out_of_range& e) {
9078       {
9079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9080       };
9081     } catch (std::exception& e) {
9082       {
9083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9084       };
9085     } catch (...) {
9086       {
9087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9088       };
9089     }
9090   }
9091 }
9092
9093
9094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9095   unsigned int jresult ;
9096   Dali::Radian arg1 ;
9097   Dali::Radian arg2 ;
9098   Dali::Radian *argp1 ;
9099   Dali::Radian *argp2 ;
9100   bool result;
9101
9102   argp1 = (Dali::Radian *)jarg1;
9103   if (!argp1) {
9104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9105     return 0;
9106   }
9107   arg1 = *argp1;
9108   argp2 = (Dali::Radian *)jarg2;
9109   if (!argp2) {
9110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9111     return 0;
9112   }
9113   arg2 = *argp2;
9114   {
9115     try {
9116       result = (bool)Dali::operator ==(arg1,arg2);
9117     } catch (std::out_of_range& e) {
9118       {
9119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9120       };
9121     } catch (std::exception& e) {
9122       {
9123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9124       };
9125     } catch (...) {
9126       {
9127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9128       };
9129     }
9130   }
9131   jresult = result;
9132   return jresult;
9133 }
9134
9135
9136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9137   unsigned int jresult ;
9138   Dali::Radian arg1 ;
9139   Dali::Radian arg2 ;
9140   Dali::Radian *argp1 ;
9141   Dali::Radian *argp2 ;
9142   bool result;
9143
9144   argp1 = (Dali::Radian *)jarg1;
9145   if (!argp1) {
9146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9147     return 0;
9148   }
9149   arg1 = *argp1;
9150   argp2 = (Dali::Radian *)jarg2;
9151   if (!argp2) {
9152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9153     return 0;
9154   }
9155   arg2 = *argp2;
9156   {
9157     try {
9158       result = (bool)Dali::operator !=(arg1,arg2);
9159     } catch (std::out_of_range& e) {
9160       {
9161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9162       };
9163     } catch (std::exception& e) {
9164       {
9165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9166       };
9167     } catch (...) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9170       };
9171     }
9172   }
9173   jresult = result;
9174   return jresult;
9175 }
9176
9177
9178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9179   unsigned int jresult ;
9180   Dali::Radian arg1 ;
9181   Dali::Degree arg2 ;
9182   Dali::Radian *argp1 ;
9183   Dali::Degree *argp2 ;
9184   bool result;
9185
9186   argp1 = (Dali::Radian *)jarg1;
9187   if (!argp1) {
9188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9189     return 0;
9190   }
9191   arg1 = *argp1;
9192   argp2 = (Dali::Degree *)jarg2;
9193   if (!argp2) {
9194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9195     return 0;
9196   }
9197   arg2 = *argp2;
9198   {
9199     try {
9200       result = (bool)Dali::operator ==(arg1,arg2);
9201     } catch (std::out_of_range& e) {
9202       {
9203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9204       };
9205     } catch (std::exception& e) {
9206       {
9207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9208       };
9209     } catch (...) {
9210       {
9211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9212       };
9213     }
9214   }
9215   jresult = result;
9216   return jresult;
9217 }
9218
9219
9220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9221   unsigned int jresult ;
9222   Dali::Radian arg1 ;
9223   Dali::Degree arg2 ;
9224   Dali::Radian *argp1 ;
9225   Dali::Degree *argp2 ;
9226   bool result;
9227
9228   argp1 = (Dali::Radian *)jarg1;
9229   if (!argp1) {
9230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9231     return 0;
9232   }
9233   arg1 = *argp1;
9234   argp2 = (Dali::Degree *)jarg2;
9235   if (!argp2) {
9236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9237     return 0;
9238   }
9239   arg2 = *argp2;
9240   {
9241     try {
9242       result = (bool)Dali::operator !=(arg1,arg2);
9243     } catch (std::out_of_range& e) {
9244       {
9245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9246       };
9247     } catch (std::exception& e) {
9248       {
9249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9250       };
9251     } catch (...) {
9252       {
9253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9254       };
9255     }
9256   }
9257   jresult = result;
9258   return jresult;
9259 }
9260
9261
9262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9263   unsigned int jresult ;
9264   Dali::Degree arg1 ;
9265   Dali::Radian arg2 ;
9266   Dali::Degree *argp1 ;
9267   Dali::Radian *argp2 ;
9268   bool result;
9269
9270   argp1 = (Dali::Degree *)jarg1;
9271   if (!argp1) {
9272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9273     return 0;
9274   }
9275   arg1 = *argp1;
9276   argp2 = (Dali::Radian *)jarg2;
9277   if (!argp2) {
9278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9279     return 0;
9280   }
9281   arg2 = *argp2;
9282   {
9283     try {
9284       result = (bool)Dali::operator ==(arg1,arg2);
9285     } catch (std::out_of_range& e) {
9286       {
9287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9288       };
9289     } catch (std::exception& e) {
9290       {
9291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (...) {
9294       {
9295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9296       };
9297     }
9298   }
9299   jresult = result;
9300   return jresult;
9301 }
9302
9303
9304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9305   unsigned int jresult ;
9306   Dali::Degree arg1 ;
9307   Dali::Radian arg2 ;
9308   Dali::Degree *argp1 ;
9309   Dali::Radian *argp2 ;
9310   bool result;
9311
9312   argp1 = (Dali::Degree *)jarg1;
9313   if (!argp1) {
9314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9315     return 0;
9316   }
9317   arg1 = *argp1;
9318   argp2 = (Dali::Radian *)jarg2;
9319   if (!argp2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9321     return 0;
9322   }
9323   arg2 = *argp2;
9324   {
9325     try {
9326       result = (bool)Dali::operator !=(arg1,arg2);
9327     } catch (std::out_of_range& e) {
9328       {
9329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9330       };
9331     } catch (std::exception& e) {
9332       {
9333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9334       };
9335     } catch (...) {
9336       {
9337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9338       };
9339     }
9340   }
9341   jresult = result;
9342   return jresult;
9343 }
9344
9345
9346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9347   unsigned int jresult ;
9348   Dali::Radian arg1 ;
9349   Dali::Radian arg2 ;
9350   Dali::Radian *argp1 ;
9351   Dali::Radian *argp2 ;
9352   bool result;
9353
9354   argp1 = (Dali::Radian *)jarg1;
9355   if (!argp1) {
9356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9357     return 0;
9358   }
9359   arg1 = *argp1;
9360   argp2 = (Dali::Radian *)jarg2;
9361   if (!argp2) {
9362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9363     return 0;
9364   }
9365   arg2 = *argp2;
9366   {
9367     try {
9368       result = (bool)Dali::operator >(arg1,arg2);
9369     } catch (std::out_of_range& e) {
9370       {
9371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (std::exception& e) {
9374       {
9375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383   jresult = result;
9384   return jresult;
9385 }
9386
9387
9388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9389   unsigned int jresult ;
9390   Dali::Radian arg1 ;
9391   Dali::Degree arg2 ;
9392   Dali::Radian *argp1 ;
9393   Dali::Degree *argp2 ;
9394   bool result;
9395
9396   argp1 = (Dali::Radian *)jarg1;
9397   if (!argp1) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9399     return 0;
9400   }
9401   arg1 = *argp1;
9402   argp2 = (Dali::Degree *)jarg2;
9403   if (!argp2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9405     return 0;
9406   }
9407   arg2 = *argp2;
9408   {
9409     try {
9410       result = (bool)Dali::operator >(arg1,arg2);
9411     } catch (std::out_of_range& e) {
9412       {
9413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9414       };
9415     } catch (std::exception& e) {
9416       {
9417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9418       };
9419     } catch (...) {
9420       {
9421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9422       };
9423     }
9424   }
9425   jresult = result;
9426   return jresult;
9427 }
9428
9429
9430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9431   unsigned int jresult ;
9432   Dali::Degree arg1 ;
9433   Dali::Radian arg2 ;
9434   Dali::Degree *argp1 ;
9435   Dali::Radian *argp2 ;
9436   bool result;
9437
9438   argp1 = (Dali::Degree *)jarg1;
9439   if (!argp1) {
9440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9441     return 0;
9442   }
9443   arg1 = *argp1;
9444   argp2 = (Dali::Radian *)jarg2;
9445   if (!argp2) {
9446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9447     return 0;
9448   }
9449   arg2 = *argp2;
9450   {
9451     try {
9452       result = (bool)Dali::operator >(arg1,arg2);
9453     } catch (std::out_of_range& e) {
9454       {
9455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (std::exception& e) {
9458       {
9459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467   jresult = result;
9468   return jresult;
9469 }
9470
9471
9472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9473   unsigned int jresult ;
9474   Dali::Radian arg1 ;
9475   Dali::Radian arg2 ;
9476   Dali::Radian *argp1 ;
9477   Dali::Radian *argp2 ;
9478   bool result;
9479
9480   argp1 = (Dali::Radian *)jarg1;
9481   if (!argp1) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9483     return 0;
9484   }
9485   arg1 = *argp1;
9486   argp2 = (Dali::Radian *)jarg2;
9487   if (!argp2) {
9488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9489     return 0;
9490   }
9491   arg2 = *argp2;
9492   {
9493     try {
9494       result = (bool)Dali::operator <(arg1,arg2);
9495     } catch (std::out_of_range& e) {
9496       {
9497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9498       };
9499     } catch (std::exception& e) {
9500       {
9501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9502       };
9503     } catch (...) {
9504       {
9505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9506       };
9507     }
9508   }
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9515   unsigned int jresult ;
9516   Dali::Radian arg1 ;
9517   Dali::Degree arg2 ;
9518   Dali::Radian *argp1 ;
9519   Dali::Degree *argp2 ;
9520   bool result;
9521
9522   argp1 = (Dali::Radian *)jarg1;
9523   if (!argp1) {
9524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9525     return 0;
9526   }
9527   arg1 = *argp1;
9528   argp2 = (Dali::Degree *)jarg2;
9529   if (!argp2) {
9530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9531     return 0;
9532   }
9533   arg2 = *argp2;
9534   {
9535     try {
9536       result = (bool)Dali::operator <(arg1,arg2);
9537     } catch (std::out_of_range& e) {
9538       {
9539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (std::exception& e) {
9542       {
9543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9544       };
9545     } catch (...) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9548       };
9549     }
9550   }
9551   jresult = result;
9552   return jresult;
9553 }
9554
9555
9556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9557   unsigned int jresult ;
9558   Dali::Degree arg1 ;
9559   Dali::Radian arg2 ;
9560   Dali::Degree *argp1 ;
9561   Dali::Radian *argp2 ;
9562   bool result;
9563
9564   argp1 = (Dali::Degree *)jarg1;
9565   if (!argp1) {
9566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9567     return 0;
9568   }
9569   arg1 = *argp1;
9570   argp2 = (Dali::Radian *)jarg2;
9571   if (!argp2) {
9572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9573     return 0;
9574   }
9575   arg2 = *argp2;
9576   {
9577     try {
9578       result = (bool)Dali::operator <(arg1,arg2);
9579     } catch (std::out_of_range& e) {
9580       {
9581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (std::exception& e) {
9584       {
9585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593   jresult = result;
9594   return jresult;
9595 }
9596
9597
9598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9599   void * jresult ;
9600   Dali::Radian arg1 ;
9601   float arg2 ;
9602   Dali::Radian *argp1 ;
9603   Dali::Radian result;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   arg2 = (float)jarg2;
9612   {
9613     try {
9614       result = Dali::operator *(arg1,arg2);
9615     } catch (std::out_of_range& e) {
9616       {
9617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9618       };
9619     } catch (std::exception& e) {
9620       {
9621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9622       };
9623     } catch (...) {
9624       {
9625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9626       };
9627     }
9628   }
9629   jresult = new Dali::Radian((const Dali::Radian &)result);
9630   return jresult;
9631 }
9632
9633
9634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9635   void * jresult ;
9636   Dali::Radian arg1 ;
9637   Dali::Radian *argp1 ;
9638   Dali::Radian result;
9639
9640   argp1 = (Dali::Radian *)jarg1;
9641   if (!argp1) {
9642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9643     return 0;
9644   }
9645   arg1 = *argp1;
9646   {
9647     try {
9648       result = Dali::operator -(arg1);
9649     } catch (std::out_of_range& e) {
9650       {
9651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9652       };
9653     } catch (std::exception& e) {
9654       {
9655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9656       };
9657     } catch (...) {
9658       {
9659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9660       };
9661     }
9662   }
9663   jresult = new Dali::Radian((const Dali::Radian &)result);
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9669   void * jresult ;
9670   Dali::Radian arg1 ;
9671   float arg2 ;
9672   float arg3 ;
9673   Dali::Radian *argp1 ;
9674   Dali::Radian result;
9675
9676   argp1 = (Dali::Radian *)jarg1;
9677   if (!argp1) {
9678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9679     return 0;
9680   }
9681   arg1 = *argp1;
9682   arg2 = (float)jarg2;
9683   arg3 = (float)jarg3;
9684   {
9685     try {
9686       result = Dali::Clamp(arg1,arg2,arg3);
9687     } catch (std::out_of_range& e) {
9688       {
9689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9690       };
9691     } catch (std::exception& e) {
9692       {
9693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9694       };
9695     } catch (...) {
9696       {
9697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9698       };
9699     }
9700   }
9701   jresult = new Dali::Radian((const Dali::Radian &)result);
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9707   void * jresult ;
9708   Dali::Quaternion *result = 0 ;
9709
9710   {
9711     try {
9712       result = (Dali::Quaternion *)new Dali::Quaternion();
9713     } catch (std::out_of_range& e) {
9714       {
9715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9716       };
9717     } catch (std::exception& e) {
9718       {
9719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9720       };
9721     } catch (...) {
9722       {
9723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9724       };
9725     }
9726   }
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9733   void * jresult ;
9734   Dali::Radian arg1 ;
9735   Dali::Vector3 *arg2 = 0 ;
9736   Dali::Radian *argp1 ;
9737   Dali::Quaternion *result = 0 ;
9738
9739   argp1 = (Dali::Radian *)jarg1;
9740   if (!argp1) {
9741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9742     return 0;
9743   }
9744   arg1 = *argp1;
9745   arg2 = (Dali::Vector3 *)jarg2;
9746   if (!arg2) {
9747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9748     return 0;
9749   }
9750   {
9751     try {
9752       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9753     } catch (std::out_of_range& e) {
9754       {
9755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9756       };
9757     } catch (std::exception& e) {
9758       {
9759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9760       };
9761     } catch (...) {
9762       {
9763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9764       };
9765     }
9766   }
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9773   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9774
9775   arg1 = (Dali::Quaternion *)jarg1;
9776   {
9777     try {
9778       delete arg1;
9779     } catch (std::out_of_range& e) {
9780       {
9781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9782       };
9783     } catch (std::exception& e) {
9784       {
9785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9786       };
9787     } catch (...) {
9788       {
9789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9790       };
9791     }
9792   }
9793 }
9794
9795
9796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9797   void * jresult ;
9798   Dali::Quaternion *result = 0 ;
9799
9800   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9801   jresult = (void *)result;
9802   return jresult;
9803 }
9804
9805
9806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9807   unsigned int jresult ;
9808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9809   bool result;
9810
9811   arg1 = (Dali::Quaternion *)jarg1;
9812   {
9813     try {
9814       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9815     } catch (std::out_of_range& e) {
9816       {
9817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9818       };
9819     } catch (std::exception& e) {
9820       {
9821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9822       };
9823     } catch (...) {
9824       {
9825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9826       };
9827     }
9828   }
9829   jresult = result;
9830   return jresult;
9831 }
9832
9833
9834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9835   unsigned int jresult ;
9836   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9837   Dali::Vector3 *arg2 = 0 ;
9838   Dali::Radian *arg3 = 0 ;
9839   bool result;
9840
9841   arg1 = (Dali::Quaternion *)jarg1;
9842   arg2 = (Dali::Vector3 *)jarg2;
9843   if (!arg2) {
9844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9845     return 0;
9846   }
9847   arg3 = (Dali::Radian *)jarg3;
9848   if (!arg3) {
9849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9850     return 0;
9851   }
9852   {
9853     try {
9854       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9855     } catch (std::out_of_range& e) {
9856       {
9857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9858       };
9859     } catch (std::exception& e) {
9860       {
9861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9862       };
9863     } catch (...) {
9864       {
9865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9866       };
9867     }
9868   }
9869   jresult = result;
9870   return jresult;
9871 }
9872
9873
9874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9875   void * jresult ;
9876   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9877   Dali::Quaternion *arg2 = 0 ;
9878   Dali::Quaternion result;
9879
9880   arg1 = (Dali::Quaternion *)jarg1;
9881   arg2 = (Dali::Quaternion *)jarg2;
9882   if (!arg2) {
9883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9884     return 0;
9885   }
9886   {
9887     try {
9888       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9889     } catch (std::out_of_range& e) {
9890       {
9891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9892       };
9893     } catch (std::exception& e) {
9894       {
9895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9896       };
9897     } catch (...) {
9898       {
9899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9900       };
9901     }
9902   }
9903   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9904   return jresult;
9905 }
9906
9907
9908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9909   void * jresult ;
9910   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9911   Dali::Quaternion *arg2 = 0 ;
9912   Dali::Quaternion result;
9913
9914   arg1 = (Dali::Quaternion *)jarg1;
9915   arg2 = (Dali::Quaternion *)jarg2;
9916   if (!arg2) {
9917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9918     return 0;
9919   }
9920   {
9921     try {
9922       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9923     } catch (std::out_of_range& e) {
9924       {
9925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9926       };
9927     } catch (std::exception& e) {
9928       {
9929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9930       };
9931     } catch (...) {
9932       {
9933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9934       };
9935     }
9936   }
9937   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9938   return jresult;
9939 }
9940
9941
9942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9943   void * jresult ;
9944   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9945   Dali::Quaternion *arg2 = 0 ;
9946   Dali::Quaternion result;
9947
9948   arg1 = (Dali::Quaternion *)jarg1;
9949   arg2 = (Dali::Quaternion *)jarg2;
9950   if (!arg2) {
9951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9952     return 0;
9953   }
9954   {
9955     try {
9956       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9957     } catch (std::out_of_range& e) {
9958       {
9959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (std::exception& e) {
9962       {
9963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9972   return jresult;
9973 }
9974
9975
9976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9977   void * jresult ;
9978   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9979   Dali::Vector3 *arg2 = 0 ;
9980   Dali::Vector3 result;
9981
9982   arg1 = (Dali::Quaternion *)jarg1;
9983   arg2 = (Dali::Vector3 *)jarg2;
9984   if (!arg2) {
9985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9986     return 0;
9987   }
9988   {
9989     try {
9990       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9991     } catch (std::out_of_range& e) {
9992       {
9993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (std::exception& e) {
9996       {
9997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9998       };
9999     } catch (...) {
10000       {
10001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10002       };
10003     }
10004   }
10005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10011   void * jresult ;
10012   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10013   Dali::Quaternion *arg2 = 0 ;
10014   Dali::Quaternion result;
10015
10016   arg1 = (Dali::Quaternion *)jarg1;
10017   arg2 = (Dali::Quaternion *)jarg2;
10018   if (!arg2) {
10019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10020     return 0;
10021   }
10022   {
10023     try {
10024       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (...) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10036       };
10037     }
10038   }
10039   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10040   return jresult;
10041 }
10042
10043
10044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10045   void * jresult ;
10046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10047   float arg2 ;
10048   Dali::Quaternion result;
10049
10050   arg1 = (Dali::Quaternion *)jarg1;
10051   arg2 = (float)jarg2;
10052   {
10053     try {
10054       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10055     } catch (std::out_of_range& e) {
10056       {
10057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10058       };
10059     } catch (std::exception& e) {
10060       {
10061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10062       };
10063     } catch (...) {
10064       {
10065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10066       };
10067     }
10068   }
10069   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10070   return jresult;
10071 }
10072
10073
10074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10075   void * jresult ;
10076   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10077   float arg2 ;
10078   Dali::Quaternion result;
10079
10080   arg1 = (Dali::Quaternion *)jarg1;
10081   arg2 = (float)jarg2;
10082   {
10083     try {
10084       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (...) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10096       };
10097     }
10098   }
10099   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10100   return jresult;
10101 }
10102
10103
10104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10105   void * jresult ;
10106   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10107   Dali::Quaternion result;
10108
10109   arg1 = (Dali::Quaternion *)jarg1;
10110   {
10111     try {
10112       result = ((Dali::Quaternion const *)arg1)->operator -();
10113     } catch (std::out_of_range& e) {
10114       {
10115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10116       };
10117     } catch (std::exception& e) {
10118       {
10119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10120       };
10121     } catch (...) {
10122       {
10123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10124       };
10125     }
10126   }
10127   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10128   return jresult;
10129 }
10130
10131
10132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10133   void * jresult ;
10134   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10135   Dali::Quaternion *arg2 = 0 ;
10136   Dali::Quaternion *result = 0 ;
10137
10138   arg1 = (Dali::Quaternion *)jarg1;
10139   arg2 = (Dali::Quaternion *)jarg2;
10140   if (!arg2) {
10141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10142     return 0;
10143   }
10144   {
10145     try {
10146       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10147     } catch (std::out_of_range& e) {
10148       {
10149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10150       };
10151     } catch (std::exception& e) {
10152       {
10153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10154       };
10155     } catch (...) {
10156       {
10157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10158       };
10159     }
10160   }
10161   jresult = (void *)result;
10162   return jresult;
10163 }
10164
10165
10166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10167   void * jresult ;
10168   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10169   Dali::Quaternion *arg2 = 0 ;
10170   Dali::Quaternion *result = 0 ;
10171
10172   arg1 = (Dali::Quaternion *)jarg1;
10173   arg2 = (Dali::Quaternion *)jarg2;
10174   if (!arg2) {
10175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10176     return 0;
10177   }
10178   {
10179     try {
10180       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10181     } catch (std::out_of_range& e) {
10182       {
10183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10184       };
10185     } catch (std::exception& e) {
10186       {
10187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10188       };
10189     } catch (...) {
10190       {
10191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10192       };
10193     }
10194   }
10195   jresult = (void *)result;
10196   return jresult;
10197 }
10198
10199
10200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10201   void * jresult ;
10202   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10203   Dali::Quaternion *arg2 = 0 ;
10204   Dali::Quaternion *result = 0 ;
10205
10206   arg1 = (Dali::Quaternion *)jarg1;
10207   arg2 = (Dali::Quaternion *)jarg2;
10208   if (!arg2) {
10209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10210     return 0;
10211   }
10212   {
10213     try {
10214       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10215     } catch (std::out_of_range& e) {
10216       {
10217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10218       };
10219     } catch (std::exception& e) {
10220       {
10221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10222       };
10223     } catch (...) {
10224       {
10225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10226       };
10227     }
10228   }
10229   jresult = (void *)result;
10230   return jresult;
10231 }
10232
10233
10234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10235   void * jresult ;
10236   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10237   float arg2 ;
10238   Dali::Quaternion *result = 0 ;
10239
10240   arg1 = (Dali::Quaternion *)jarg1;
10241   arg2 = (float)jarg2;
10242   {
10243     try {
10244       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10245     } catch (std::out_of_range& e) {
10246       {
10247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10248       };
10249     } catch (std::exception& e) {
10250       {
10251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10252       };
10253     } catch (...) {
10254       {
10255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10256       };
10257     }
10258   }
10259   jresult = (void *)result;
10260   return jresult;
10261 }
10262
10263
10264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10265   void * jresult ;
10266   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10267   float arg2 ;
10268   Dali::Quaternion *result = 0 ;
10269
10270   arg1 = (Dali::Quaternion *)jarg1;
10271   arg2 = (float)jarg2;
10272   {
10273     try {
10274       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289   jresult = (void *)result;
10290   return jresult;
10291 }
10292
10293
10294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10295   unsigned int jresult ;
10296   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10297   Dali::Quaternion *arg2 = 0 ;
10298   bool result;
10299
10300   arg1 = (Dali::Quaternion *)jarg1;
10301   arg2 = (Dali::Quaternion *)jarg2;
10302   if (!arg2) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10304     return 0;
10305   }
10306   {
10307     try {
10308       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10309     } catch (std::out_of_range& e) {
10310       {
10311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10312       };
10313     } catch (std::exception& e) {
10314       {
10315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10316       };
10317     } catch (...) {
10318       {
10319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10320       };
10321     }
10322   }
10323   jresult = result;
10324   return jresult;
10325 }
10326
10327
10328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10329   unsigned int jresult ;
10330   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10331   Dali::Quaternion *arg2 = 0 ;
10332   bool result;
10333
10334   arg1 = (Dali::Quaternion *)jarg1;
10335   arg2 = (Dali::Quaternion *)jarg2;
10336   if (!arg2) {
10337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10338     return 0;
10339   }
10340   {
10341     try {
10342       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10343     } catch (std::out_of_range& e) {
10344       {
10345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10346       };
10347     } catch (std::exception& e) {
10348       {
10349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10350       };
10351     } catch (...) {
10352       {
10353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10354       };
10355     }
10356   }
10357   jresult = result;
10358   return jresult;
10359 }
10360
10361
10362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10363   float jresult ;
10364   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10365   float result;
10366
10367   arg1 = (Dali::Quaternion *)jarg1;
10368   {
10369     try {
10370       result = (float)((Dali::Quaternion const *)arg1)->Length();
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (...) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10382       };
10383     }
10384   }
10385   jresult = result;
10386   return jresult;
10387 }
10388
10389
10390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10391   float jresult ;
10392   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10393   float result;
10394
10395   arg1 = (Dali::Quaternion *)jarg1;
10396   {
10397     try {
10398       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10399     } catch (std::out_of_range& e) {
10400       {
10401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10402       };
10403     } catch (std::exception& e) {
10404       {
10405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10406       };
10407     } catch (...) {
10408       {
10409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10410       };
10411     }
10412   }
10413   jresult = result;
10414   return jresult;
10415 }
10416
10417
10418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10419   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10420
10421   arg1 = (Dali::Quaternion *)jarg1;
10422   {
10423     try {
10424       (arg1)->Normalize();
10425     } catch (std::out_of_range& e) {
10426       {
10427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10428       };
10429     } catch (std::exception& e) {
10430       {
10431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10432       };
10433     } catch (...) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10436       };
10437     }
10438   }
10439 }
10440
10441
10442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10443   void * jresult ;
10444   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10445   Dali::Quaternion result;
10446
10447   arg1 = (Dali::Quaternion *)jarg1;
10448   {
10449     try {
10450       result = ((Dali::Quaternion const *)arg1)->Normalized();
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (...) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10462       };
10463     }
10464   }
10465   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10466   return jresult;
10467 }
10468
10469
10470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10471   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10472
10473   arg1 = (Dali::Quaternion *)jarg1;
10474   {
10475     try {
10476       (arg1)->Conjugate();
10477     } catch (std::out_of_range& e) {
10478       {
10479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10480       };
10481     } catch (std::exception& e) {
10482       {
10483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10484       };
10485     } catch (...) {
10486       {
10487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10488       };
10489     }
10490   }
10491 }
10492
10493
10494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10495   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10496
10497   arg1 = (Dali::Quaternion *)jarg1;
10498   {
10499     try {
10500       (arg1)->Invert();
10501     } catch (std::out_of_range& e) {
10502       {
10503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10504       };
10505     } catch (std::exception& e) {
10506       {
10507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10508       };
10509     } catch (...) {
10510       {
10511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10512       };
10513     }
10514   }
10515 }
10516
10517
10518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10519   void * jresult ;
10520   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10521   Dali::Quaternion result;
10522
10523   arg1 = (Dali::Quaternion *)jarg1;
10524   {
10525     try {
10526       result = ((Dali::Quaternion const *)arg1)->Log();
10527     } catch (std::out_of_range& e) {
10528       {
10529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10530       };
10531     } catch (std::exception& e) {
10532       {
10533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10534       };
10535     } catch (...) {
10536       {
10537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10538       };
10539     }
10540   }
10541   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10542   return jresult;
10543 }
10544
10545
10546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10547   void * jresult ;
10548   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10549   Dali::Quaternion result;
10550
10551   arg1 = (Dali::Quaternion *)jarg1;
10552   {
10553     try {
10554       result = ((Dali::Quaternion const *)arg1)->Exp();
10555     } catch (std::out_of_range& e) {
10556       {
10557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10558       };
10559     } catch (std::exception& e) {
10560       {
10561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (...) {
10564       {
10565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10566       };
10567     }
10568   }
10569   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10570   return jresult;
10571 }
10572
10573
10574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10575   float jresult ;
10576   Dali::Quaternion *arg1 = 0 ;
10577   Dali::Quaternion *arg2 = 0 ;
10578   float result;
10579
10580   arg1 = (Dali::Quaternion *)jarg1;
10581   if (!arg1) {
10582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10583     return 0;
10584   }
10585   arg2 = (Dali::Quaternion *)jarg2;
10586   if (!arg2) {
10587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10588     return 0;
10589   }
10590   {
10591     try {
10592       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10593     } catch (std::out_of_range& e) {
10594       {
10595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10596       };
10597     } catch (std::exception& e) {
10598       {
10599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10600       };
10601     } catch (...) {
10602       {
10603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10604       };
10605     }
10606   }
10607   jresult = result;
10608   return jresult;
10609 }
10610
10611
10612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10613   void * jresult ;
10614   Dali::Quaternion *arg1 = 0 ;
10615   Dali::Quaternion *arg2 = 0 ;
10616   float arg3 ;
10617   Dali::Quaternion result;
10618
10619   arg1 = (Dali::Quaternion *)jarg1;
10620   if (!arg1) {
10621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10622     return 0;
10623   }
10624   arg2 = (Dali::Quaternion *)jarg2;
10625   if (!arg2) {
10626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10627     return 0;
10628   }
10629   arg3 = (float)jarg3;
10630   {
10631     try {
10632       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10633     } catch (std::out_of_range& e) {
10634       {
10635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10636       };
10637     } catch (std::exception& e) {
10638       {
10639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10640       };
10641     } catch (...) {
10642       {
10643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10644       };
10645     }
10646   }
10647   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10648   return jresult;
10649 }
10650
10651
10652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10653   void * jresult ;
10654   Dali::Quaternion *arg1 = 0 ;
10655   Dali::Quaternion *arg2 = 0 ;
10656   float arg3 ;
10657   Dali::Quaternion result;
10658
10659   arg1 = (Dali::Quaternion *)jarg1;
10660   if (!arg1) {
10661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10662     return 0;
10663   }
10664   arg2 = (Dali::Quaternion *)jarg2;
10665   if (!arg2) {
10666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10667     return 0;
10668   }
10669   arg3 = (float)jarg3;
10670   {
10671     try {
10672       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10673     } catch (std::out_of_range& e) {
10674       {
10675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (std::exception& e) {
10678       {
10679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10688   return jresult;
10689 }
10690
10691
10692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10693   void * jresult ;
10694   Dali::Quaternion *arg1 = 0 ;
10695   Dali::Quaternion *arg2 = 0 ;
10696   float arg3 ;
10697   Dali::Quaternion result;
10698
10699   arg1 = (Dali::Quaternion *)jarg1;
10700   if (!arg1) {
10701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10702     return 0;
10703   }
10704   arg2 = (Dali::Quaternion *)jarg2;
10705   if (!arg2) {
10706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10707     return 0;
10708   }
10709   arg3 = (float)jarg3;
10710   {
10711     try {
10712       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10713     } catch (std::out_of_range& e) {
10714       {
10715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10716       };
10717     } catch (std::exception& e) {
10718       {
10719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10720       };
10721     } catch (...) {
10722       {
10723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10724       };
10725     }
10726   }
10727   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10728   return jresult;
10729 }
10730
10731
10732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10733   void * jresult ;
10734   Dali::Quaternion *arg1 = 0 ;
10735   Dali::Quaternion *arg2 = 0 ;
10736   Dali::Quaternion *arg3 = 0 ;
10737   Dali::Quaternion *arg4 = 0 ;
10738   float arg5 ;
10739   Dali::Quaternion result;
10740
10741   arg1 = (Dali::Quaternion *)jarg1;
10742   if (!arg1) {
10743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10744     return 0;
10745   }
10746   arg2 = (Dali::Quaternion *)jarg2;
10747   if (!arg2) {
10748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10749     return 0;
10750   }
10751   arg3 = (Dali::Quaternion *)jarg3;
10752   if (!arg3) {
10753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10754     return 0;
10755   }
10756   arg4 = (Dali::Quaternion *)jarg4;
10757   if (!arg4) {
10758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10759     return 0;
10760   }
10761   arg5 = (float)jarg5;
10762   {
10763     try {
10764       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10765     } catch (std::out_of_range& e) {
10766       {
10767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10768       };
10769     } catch (std::exception& e) {
10770       {
10771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10772       };
10773     } catch (...) {
10774       {
10775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10776       };
10777     }
10778   }
10779   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10780   return jresult;
10781 }
10782
10783
10784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10785   float jresult ;
10786   Dali::Quaternion *arg1 = 0 ;
10787   Dali::Quaternion *arg2 = 0 ;
10788   float result;
10789
10790   arg1 = (Dali::Quaternion *)jarg1;
10791   if (!arg1) {
10792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10793     return 0;
10794   }
10795   arg2 = (Dali::Quaternion *)jarg2;
10796   if (!arg2) {
10797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10798     return 0;
10799   }
10800   {
10801     try {
10802       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10803     } catch (std::out_of_range& e) {
10804       {
10805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10806       };
10807     } catch (std::exception& e) {
10808       {
10809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10810       };
10811     } catch (...) {
10812       {
10813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10814       };
10815     }
10816   }
10817   jresult = result;
10818   return jresult;
10819 }
10820
10821
10822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10823   void * jresult ;
10824   Dali::Matrix *result = 0 ;
10825
10826   {
10827     try {
10828       result = (Dali::Matrix *)new Dali::Matrix();
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843   jresult = (void *)result;
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10849   void * jresult ;
10850   bool arg1 ;
10851   Dali::Matrix *result = 0 ;
10852
10853   arg1 = jarg1 ? true : false;
10854   {
10855     try {
10856       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10857     } catch (std::out_of_range& e) {
10858       {
10859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10860       };
10861     } catch (std::exception& e) {
10862       {
10863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10864       };
10865     } catch (...) {
10866       {
10867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10868       };
10869     }
10870   }
10871   jresult = (void *)result;
10872   return jresult;
10873 }
10874
10875
10876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10877   void * jresult ;
10878   float *arg1 = (float *) 0 ;
10879   Dali::Matrix *result = 0 ;
10880
10881   arg1 = jarg1;
10882   {
10883     try {
10884       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10885     } catch (std::out_of_range& e) {
10886       {
10887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10888       };
10889     } catch (std::exception& e) {
10890       {
10891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10892       };
10893     } catch (...) {
10894       {
10895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10896       };
10897     }
10898   }
10899   jresult = (void *)result;
10900
10901
10902   return jresult;
10903 }
10904
10905
10906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10907   void * jresult ;
10908   Dali::Quaternion *arg1 = 0 ;
10909   Dali::Matrix *result = 0 ;
10910
10911   arg1 = (Dali::Quaternion *)jarg1;
10912   if (!arg1) {
10913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10914     return 0;
10915   }
10916   {
10917     try {
10918       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10919     } catch (std::out_of_range& e) {
10920       {
10921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10922       };
10923     } catch (std::exception& e) {
10924       {
10925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10926       };
10927     } catch (...) {
10928       {
10929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10930       };
10931     }
10932   }
10933   jresult = (void *)result;
10934   return jresult;
10935 }
10936
10937
10938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10939   void * jresult ;
10940   Dali::Matrix *arg1 = 0 ;
10941   Dali::Matrix *result = 0 ;
10942
10943   arg1 = (Dali::Matrix *)jarg1;
10944   if (!arg1) {
10945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10946     return 0;
10947   }
10948   {
10949     try {
10950       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10951     } catch (std::out_of_range& e) {
10952       {
10953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10954       };
10955     } catch (std::exception& e) {
10956       {
10957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10958       };
10959     } catch (...) {
10960       {
10961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10962       };
10963     }
10964   }
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10971   void * jresult ;
10972   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10973   Dali::Matrix *arg2 = 0 ;
10974   Dali::Matrix *result = 0 ;
10975
10976   arg1 = (Dali::Matrix *)jarg1;
10977   arg2 = (Dali::Matrix *)jarg2;
10978   if (!arg2) {
10979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10980     return 0;
10981   }
10982   {
10983     try {
10984       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10985     } catch (std::out_of_range& e) {
10986       {
10987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10988       };
10989     } catch (std::exception& e) {
10990       {
10991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10992       };
10993     } catch (...) {
10994       {
10995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10996       };
10997     }
10998   }
10999   jresult = (void *)result;
11000   return jresult;
11001 }
11002
11003
11004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11005   void * jresult ;
11006   Dali::Matrix *result = 0 ;
11007
11008   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11009   jresult = (void *)result;
11010   return jresult;
11011 }
11012
11013
11014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11015   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11016
11017   arg1 = (Dali::Matrix *)jarg1;
11018   {
11019     try {
11020       (arg1)->SetIdentity();
11021     } catch (std::out_of_range& e) {
11022       {
11023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11024       };
11025     } catch (std::exception& e) {
11026       {
11027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11028       };
11029     } catch (...) {
11030       {
11031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11032       };
11033     }
11034   }
11035 }
11036
11037
11038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11039   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11040   Dali::Vector3 *arg2 = 0 ;
11041
11042   arg1 = (Dali::Matrix *)jarg1;
11043   arg2 = (Dali::Vector3 *)jarg2;
11044   if (!arg2) {
11045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11046     return ;
11047   }
11048   {
11049     try {
11050       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11051     } catch (std::out_of_range& e) {
11052       {
11053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11054       };
11055     } catch (std::exception& e) {
11056       {
11057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11058       };
11059     } catch (...) {
11060       {
11061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11062       };
11063     }
11064   }
11065 }
11066
11067
11068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11069   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11070   Dali::Matrix *arg2 = 0 ;
11071
11072   arg1 = (Dali::Matrix *)jarg1;
11073   arg2 = (Dali::Matrix *)jarg2;
11074   if (!arg2) {
11075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11076     return ;
11077   }
11078   {
11079     try {
11080       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11081     } catch (std::out_of_range& e) {
11082       {
11083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11084       };
11085     } catch (std::exception& e) {
11086       {
11087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11088       };
11089     } catch (...) {
11090       {
11091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11092       };
11093     }
11094   }
11095 }
11096
11097
11098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11099   unsigned int jresult ;
11100   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11101   bool result;
11102
11103   arg1 = (Dali::Matrix *)jarg1;
11104   {
11105     try {
11106       result = (bool)(arg1)->Invert();
11107     } catch (std::out_of_range& e) {
11108       {
11109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11110       };
11111     } catch (std::exception& e) {
11112       {
11113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11114       };
11115     } catch (...) {
11116       {
11117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11118       };
11119     }
11120   }
11121   jresult = result;
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11127   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11128
11129   arg1 = (Dali::Matrix *)jarg1;
11130   {
11131     try {
11132       (arg1)->Transpose();
11133     } catch (std::out_of_range& e) {
11134       {
11135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11136       };
11137     } catch (std::exception& e) {
11138       {
11139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11140       };
11141     } catch (...) {
11142       {
11143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11144       };
11145     }
11146   }
11147 }
11148
11149
11150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11151   void * jresult ;
11152   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11153   Dali::Vector3 result;
11154
11155   arg1 = (Dali::Matrix *)jarg1;
11156   {
11157     try {
11158       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11159     } catch (std::out_of_range& e) {
11160       {
11161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11162       };
11163     } catch (std::exception& e) {
11164       {
11165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11166       };
11167     } catch (...) {
11168       {
11169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11170       };
11171     }
11172   }
11173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11174   return jresult;
11175 }
11176
11177
11178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11179   void * jresult ;
11180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11181   Dali::Vector3 result;
11182
11183   arg1 = (Dali::Matrix *)jarg1;
11184   {
11185     try {
11186       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (...) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11198       };
11199     }
11200   }
11201   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11207   void * jresult ;
11208   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11209   Dali::Vector3 result;
11210
11211   arg1 = (Dali::Matrix *)jarg1;
11212   {
11213     try {
11214       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11215     } catch (std::out_of_range& e) {
11216       {
11217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (std::exception& e) {
11220       {
11221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11226       };
11227     }
11228   }
11229   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11230   return jresult;
11231 }
11232
11233
11234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11235   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11236   Dali::Vector3 *arg2 = 0 ;
11237
11238   arg1 = (Dali::Matrix *)jarg1;
11239   arg2 = (Dali::Vector3 *)jarg2;
11240   if (!arg2) {
11241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11242     return ;
11243   }
11244   {
11245     try {
11246       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11254       };
11255     } catch (...) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11258       };
11259     }
11260   }
11261 }
11262
11263
11264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11265   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11266   Dali::Vector3 *arg2 = 0 ;
11267
11268   arg1 = (Dali::Matrix *)jarg1;
11269   arg2 = (Dali::Vector3 *)jarg2;
11270   if (!arg2) {
11271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11272     return ;
11273   }
11274   {
11275     try {
11276       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11277     } catch (std::out_of_range& e) {
11278       {
11279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11280       };
11281     } catch (std::exception& e) {
11282       {
11283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11284       };
11285     } catch (...) {
11286       {
11287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11288       };
11289     }
11290   }
11291 }
11292
11293
11294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11295   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11296   Dali::Vector3 *arg2 = 0 ;
11297
11298   arg1 = (Dali::Matrix *)jarg1;
11299   arg2 = (Dali::Vector3 *)jarg2;
11300   if (!arg2) {
11301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11302     return ;
11303   }
11304   {
11305     try {
11306       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11307     } catch (std::out_of_range& e) {
11308       {
11309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11310       };
11311     } catch (std::exception& e) {
11312       {
11313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11314       };
11315     } catch (...) {
11316       {
11317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11318       };
11319     }
11320   }
11321 }
11322
11323
11324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11325   void * jresult ;
11326   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11327   Dali::Vector4 *result = 0 ;
11328
11329   arg1 = (Dali::Matrix *)jarg1;
11330   {
11331     try {
11332       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11333     } catch (std::out_of_range& e) {
11334       {
11335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11336       };
11337     } catch (std::exception& e) {
11338       {
11339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11340       };
11341     } catch (...) {
11342       {
11343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11344       };
11345     }
11346   }
11347   jresult = (void *)result;
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11353   void * jresult ;
11354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11355   Dali::Vector3 *result = 0 ;
11356
11357   arg1 = (Dali::Matrix *)jarg1;
11358   {
11359     try {
11360       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (...) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11372       };
11373     }
11374   }
11375   jresult = (void *)result;
11376   return jresult;
11377 }
11378
11379
11380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11381   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11382   Dali::Vector4 *arg2 = 0 ;
11383
11384   arg1 = (Dali::Matrix *)jarg1;
11385   arg2 = (Dali::Vector4 *)jarg2;
11386   if (!arg2) {
11387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11388     return ;
11389   }
11390   {
11391     try {
11392       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11393     } catch (std::out_of_range& e) {
11394       {
11395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11396       };
11397     } catch (std::exception& e) {
11398       {
11399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11404       };
11405     }
11406   }
11407 }
11408
11409
11410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11411   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11412   Dali::Vector3 *arg2 = 0 ;
11413
11414   arg1 = (Dali::Matrix *)jarg1;
11415   arg2 = (Dali::Vector3 *)jarg2;
11416   if (!arg2) {
11417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11418     return ;
11419   }
11420   {
11421     try {
11422       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11423     } catch (std::out_of_range& e) {
11424       {
11425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11426       };
11427     } catch (std::exception& e) {
11428       {
11429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11430       };
11431     } catch (...) {
11432       {
11433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11434       };
11435     }
11436   }
11437 }
11438
11439
11440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11441   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11442
11443   arg1 = (Dali::Matrix *)jarg1;
11444   {
11445     try {
11446       (arg1)->OrthoNormalize();
11447     } catch (std::out_of_range& e) {
11448       {
11449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11450       };
11451     } catch (std::exception& e) {
11452       {
11453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11454       };
11455     } catch (...) {
11456       {
11457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11458       };
11459     }
11460   }
11461 }
11462
11463
11464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11465   void * jresult ;
11466   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11467   float *result = 0 ;
11468
11469   arg1 = (Dali::Matrix *)jarg1;
11470   {
11471     try {
11472       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11473     } catch (std::out_of_range& e) {
11474       {
11475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11476       };
11477     } catch (std::exception& e) {
11478       {
11479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11480       };
11481     } catch (...) {
11482       {
11483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11484       };
11485     }
11486   }
11487   jresult = (void *)result;
11488   return jresult;
11489 }
11490
11491
11492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11493   Dali::Matrix *arg1 = 0 ;
11494   Dali::Matrix *arg2 = 0 ;
11495   Dali::Matrix *arg3 = 0 ;
11496
11497   arg1 = (Dali::Matrix *)jarg1;
11498   if (!arg1) {
11499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11500     return ;
11501   }
11502   arg2 = (Dali::Matrix *)jarg2;
11503   if (!arg2) {
11504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11505     return ;
11506   }
11507   arg3 = (Dali::Matrix *)jarg3;
11508   if (!arg3) {
11509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11510     return ;
11511   }
11512   {
11513     try {
11514       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11522       };
11523     } catch (...) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11526       };
11527     }
11528   }
11529 }
11530
11531
11532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11533   Dali::Matrix *arg1 = 0 ;
11534   Dali::Matrix *arg2 = 0 ;
11535   Dali::Quaternion *arg3 = 0 ;
11536
11537   arg1 = (Dali::Matrix *)jarg1;
11538   if (!arg1) {
11539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11540     return ;
11541   }
11542   arg2 = (Dali::Matrix *)jarg2;
11543   if (!arg2) {
11544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11545     return ;
11546   }
11547   arg3 = (Dali::Quaternion *)jarg3;
11548   if (!arg3) {
11549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11550     return ;
11551   }
11552   {
11553     try {
11554       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11562       };
11563     } catch (...) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11566       };
11567     }
11568   }
11569 }
11570
11571
11572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11573   void * jresult ;
11574   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11575   Dali::Vector4 *arg2 = 0 ;
11576   Dali::Vector4 result;
11577
11578   arg1 = (Dali::Matrix *)jarg1;
11579   arg2 = (Dali::Vector4 *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (...) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11598       };
11599     }
11600   }
11601   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11602   return jresult;
11603 }
11604
11605
11606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11607   unsigned int jresult ;
11608   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11609   Dali::Matrix *arg2 = 0 ;
11610   bool result;
11611
11612   arg1 = (Dali::Matrix *)jarg1;
11613   arg2 = (Dali::Matrix *)jarg2;
11614   if (!arg2) {
11615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11616     return 0;
11617   }
11618   {
11619     try {
11620       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11621     } catch (std::out_of_range& e) {
11622       {
11623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11624       };
11625     } catch (std::exception& e) {
11626       {
11627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11628       };
11629     } catch (...) {
11630       {
11631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11632       };
11633     }
11634   }
11635   jresult = result;
11636   return jresult;
11637 }
11638
11639
11640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11641   unsigned int jresult ;
11642   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11643   Dali::Matrix *arg2 = 0 ;
11644   bool result;
11645
11646   arg1 = (Dali::Matrix *)jarg1;
11647   arg2 = (Dali::Matrix *)jarg2;
11648   if (!arg2) {
11649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11650     return 0;
11651   }
11652   {
11653     try {
11654       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11655     } catch (std::out_of_range& e) {
11656       {
11657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11658       };
11659     } catch (std::exception& e) {
11660       {
11661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (...) {
11664       {
11665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11666       };
11667     }
11668   }
11669   jresult = result;
11670   return jresult;
11671 }
11672
11673
11674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11675   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11676   Dali::Vector3 *arg2 = 0 ;
11677   Dali::Quaternion *arg3 = 0 ;
11678   Dali::Vector3 *arg4 = 0 ;
11679
11680   arg1 = (Dali::Matrix *)jarg1;
11681   arg2 = (Dali::Vector3 *)jarg2;
11682   if (!arg2) {
11683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11684     return ;
11685   }
11686   arg3 = (Dali::Quaternion *)jarg3;
11687   if (!arg3) {
11688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11689     return ;
11690   }
11691   arg4 = (Dali::Vector3 *)jarg4;
11692   if (!arg4) {
11693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11694     return ;
11695   }
11696   {
11697     try {
11698       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11699     } catch (std::out_of_range& e) {
11700       {
11701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11702       };
11703     } catch (std::exception& e) {
11704       {
11705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11706       };
11707     } catch (...) {
11708       {
11709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11710       };
11711     }
11712   }
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11717   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11718   Dali::Vector3 *arg2 = 0 ;
11719   Dali::Quaternion *arg3 = 0 ;
11720   Dali::Vector3 *arg4 = 0 ;
11721
11722   arg1 = (Dali::Matrix *)jarg1;
11723   arg2 = (Dali::Vector3 *)jarg2;
11724   if (!arg2) {
11725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11726     return ;
11727   }
11728   arg3 = (Dali::Quaternion *)jarg3;
11729   if (!arg3) {
11730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11731     return ;
11732   }
11733   arg4 = (Dali::Vector3 *)jarg4;
11734   if (!arg4) {
11735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11736     return ;
11737   }
11738   {
11739     try {
11740       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11741     } catch (std::out_of_range& e) {
11742       {
11743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11744       };
11745     } catch (std::exception& e) {
11746       {
11747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11748       };
11749     } catch (...) {
11750       {
11751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11752       };
11753     }
11754   }
11755 }
11756
11757
11758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11759   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11760   Dali::Vector3 *arg2 = 0 ;
11761   Dali::Vector3 *arg3 = 0 ;
11762   Dali::Vector3 *arg4 = 0 ;
11763   Dali::Vector3 *arg5 = 0 ;
11764
11765   arg1 = (Dali::Matrix *)jarg1;
11766   arg2 = (Dali::Vector3 *)jarg2;
11767   if (!arg2) {
11768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11769     return ;
11770   }
11771   arg3 = (Dali::Vector3 *)jarg3;
11772   if (!arg3) {
11773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11774     return ;
11775   }
11776   arg4 = (Dali::Vector3 *)jarg4;
11777   if (!arg4) {
11778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11779     return ;
11780   }
11781   arg5 = (Dali::Vector3 *)jarg5;
11782   if (!arg5) {
11783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11784     return ;
11785   }
11786   {
11787     try {
11788       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11789     } catch (std::out_of_range& e) {
11790       {
11791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (std::exception& e) {
11794       {
11795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803 }
11804
11805
11806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11807   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11808   Dali::Vector3 *arg2 = 0 ;
11809   Dali::Quaternion *arg3 = 0 ;
11810   Dali::Vector3 *arg4 = 0 ;
11811
11812   arg1 = (Dali::Matrix *)jarg1;
11813   arg2 = (Dali::Vector3 *)jarg2;
11814   if (!arg2) {
11815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11816     return ;
11817   }
11818   arg3 = (Dali::Quaternion *)jarg3;
11819   if (!arg3) {
11820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11821     return ;
11822   }
11823   arg4 = (Dali::Vector3 *)jarg4;
11824   if (!arg4) {
11825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11826     return ;
11827   }
11828   {
11829     try {
11830       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11831     } catch (std::out_of_range& e) {
11832       {
11833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11834       };
11835     } catch (std::exception& e) {
11836       {
11837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11838       };
11839     } catch (...) {
11840       {
11841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11842       };
11843     }
11844   }
11845 }
11846
11847
11848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11849   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11850
11851   arg1 = (Dali::Matrix *)jarg1;
11852   {
11853     try {
11854       delete arg1;
11855     } catch (std::out_of_range& e) {
11856       {
11857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11858       };
11859     } catch (std::exception& e) {
11860       {
11861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11862       };
11863     } catch (...) {
11864       {
11865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11866       };
11867     }
11868   }
11869 }
11870
11871
11872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11873   void * jresult ;
11874   Dali::Matrix3 *result = 0 ;
11875
11876   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11877   jresult = (void *)result;
11878   return jresult;
11879 }
11880
11881
11882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11883   void * jresult ;
11884   Dali::Matrix3 *result = 0 ;
11885
11886   {
11887     try {
11888       result = (Dali::Matrix3 *)new Dali::Matrix3();
11889     } catch (std::out_of_range& e) {
11890       {
11891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11892       };
11893     } catch (std::exception& e) {
11894       {
11895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11896       };
11897     } catch (...) {
11898       {
11899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11900       };
11901     }
11902   }
11903   jresult = (void *)result;
11904   return jresult;
11905 }
11906
11907
11908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11909   void * jresult ;
11910   Dali::Matrix3 *arg1 = 0 ;
11911   Dali::Matrix3 *result = 0 ;
11912
11913   arg1 = (Dali::Matrix3 *)jarg1;
11914   if (!arg1) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935   jresult = (void *)result;
11936   return jresult;
11937 }
11938
11939
11940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11941   void * jresult ;
11942   Dali::Matrix *arg1 = 0 ;
11943   Dali::Matrix3 *result = 0 ;
11944
11945   arg1 = (Dali::Matrix *)jarg1;
11946   if (!arg1) {
11947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11948     return 0;
11949   }
11950   {
11951     try {
11952       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11953     } catch (std::out_of_range& e) {
11954       {
11955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11956       };
11957     } catch (std::exception& e) {
11958       {
11959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11960       };
11961     } catch (...) {
11962       {
11963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11964       };
11965     }
11966   }
11967   jresult = (void *)result;
11968   return jresult;
11969 }
11970
11971
11972 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) {
11973   void * jresult ;
11974   float arg1 ;
11975   float arg2 ;
11976   float arg3 ;
11977   float arg4 ;
11978   float arg5 ;
11979   float arg6 ;
11980   float arg7 ;
11981   float arg8 ;
11982   float arg9 ;
11983   Dali::Matrix3 *result = 0 ;
11984
11985   arg1 = (float)jarg1;
11986   arg2 = (float)jarg2;
11987   arg3 = (float)jarg3;
11988   arg4 = (float)jarg4;
11989   arg5 = (float)jarg5;
11990   arg6 = (float)jarg6;
11991   arg7 = (float)jarg7;
11992   arg8 = (float)jarg8;
11993   arg9 = (float)jarg9;
11994   {
11995     try {
11996       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11997     } catch (std::out_of_range& e) {
11998       {
11999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12000       };
12001     } catch (std::exception& e) {
12002       {
12003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12004       };
12005     } catch (...) {
12006       {
12007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12008       };
12009     }
12010   }
12011   jresult = (void *)result;
12012   return jresult;
12013 }
12014
12015
12016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12017   void * jresult ;
12018   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12019   Dali::Matrix3 *arg2 = 0 ;
12020   Dali::Matrix3 *result = 0 ;
12021
12022   arg1 = (Dali::Matrix3 *)jarg1;
12023   arg2 = (Dali::Matrix3 *)jarg2;
12024   if (!arg2) {
12025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12026     return 0;
12027   }
12028   {
12029     try {
12030       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12031     } catch (std::out_of_range& e) {
12032       {
12033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12034       };
12035     } catch (std::exception& e) {
12036       {
12037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12038       };
12039     } catch (...) {
12040       {
12041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12042       };
12043     }
12044   }
12045   jresult = (void *)result;
12046   return jresult;
12047 }
12048
12049
12050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12051   void * jresult ;
12052   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12053   Dali::Matrix *arg2 = 0 ;
12054   Dali::Matrix3 *result = 0 ;
12055
12056   arg1 = (Dali::Matrix3 *)jarg1;
12057   arg2 = (Dali::Matrix *)jarg2;
12058   if (!arg2) {
12059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12060     return 0;
12061   }
12062   {
12063     try {
12064       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12065     } catch (std::out_of_range& e) {
12066       {
12067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12068       };
12069     } catch (std::exception& e) {
12070       {
12071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12072       };
12073     } catch (...) {
12074       {
12075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12076       };
12077     }
12078   }
12079   jresult = (void *)result;
12080   return jresult;
12081 }
12082
12083
12084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12085   unsigned int jresult ;
12086   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12087   Dali::Matrix3 *arg2 = 0 ;
12088   bool result;
12089
12090   arg1 = (Dali::Matrix3 *)jarg1;
12091   arg2 = (Dali::Matrix3 *)jarg2;
12092   if (!arg2) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12094     return 0;
12095   }
12096   {
12097     try {
12098       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12099     } catch (std::out_of_range& e) {
12100       {
12101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12102       };
12103     } catch (std::exception& e) {
12104       {
12105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12106       };
12107     } catch (...) {
12108       {
12109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12110       };
12111     }
12112   }
12113   jresult = result;
12114   return jresult;
12115 }
12116
12117
12118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12119   unsigned int jresult ;
12120   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12121   Dali::Matrix3 *arg2 = 0 ;
12122   bool result;
12123
12124   arg1 = (Dali::Matrix3 *)jarg1;
12125   arg2 = (Dali::Matrix3 *)jarg2;
12126   if (!arg2) {
12127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12128     return 0;
12129   }
12130   {
12131     try {
12132       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12133     } catch (std::out_of_range& e) {
12134       {
12135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12136       };
12137     } catch (std::exception& e) {
12138       {
12139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12140       };
12141     } catch (...) {
12142       {
12143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12144       };
12145     }
12146   }
12147   jresult = result;
12148   return jresult;
12149 }
12150
12151
12152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12153   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12154
12155   arg1 = (Dali::Matrix3 *)jarg1;
12156   {
12157     try {
12158       delete arg1;
12159     } catch (std::out_of_range& e) {
12160       {
12161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12162       };
12163     } catch (std::exception& e) {
12164       {
12165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12166       };
12167     } catch (...) {
12168       {
12169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12170       };
12171     }
12172   }
12173 }
12174
12175
12176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12177   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12178
12179   arg1 = (Dali::Matrix3 *)jarg1;
12180   {
12181     try {
12182       (arg1)->SetIdentity();
12183     } catch (std::out_of_range& e) {
12184       {
12185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12186       };
12187     } catch (std::exception& e) {
12188       {
12189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12190       };
12191     } catch (...) {
12192       {
12193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12194       };
12195     }
12196   }
12197 }
12198
12199
12200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12201   void * jresult ;
12202   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12203   float *result = 0 ;
12204
12205   arg1 = (Dali::Matrix3 *)jarg1;
12206   {
12207     try {
12208       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12209     } catch (std::out_of_range& e) {
12210       {
12211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (std::exception& e) {
12214       {
12215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12216       };
12217     } catch (...) {
12218       {
12219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12220       };
12221     }
12222   }
12223   jresult = (void *)result;
12224   return jresult;
12225 }
12226
12227
12228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12229   unsigned int jresult ;
12230   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12231   bool result;
12232
12233   arg1 = (Dali::Matrix3 *)jarg1;
12234   {
12235     try {
12236       result = (bool)(arg1)->Invert();
12237     } catch (std::out_of_range& e) {
12238       {
12239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12240       };
12241     } catch (std::exception& e) {
12242       {
12243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12244       };
12245     } catch (...) {
12246       {
12247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12248       };
12249     }
12250   }
12251   jresult = result;
12252   return jresult;
12253 }
12254
12255
12256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12257   unsigned int jresult ;
12258   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12259   bool result;
12260
12261   arg1 = (Dali::Matrix3 *)jarg1;
12262   {
12263     try {
12264       result = (bool)(arg1)->Transpose();
12265     } catch (std::out_of_range& e) {
12266       {
12267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12268       };
12269     } catch (std::exception& e) {
12270       {
12271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12272       };
12273     } catch (...) {
12274       {
12275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12276       };
12277     }
12278   }
12279   jresult = result;
12280   return jresult;
12281 }
12282
12283
12284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12286   float arg2 ;
12287
12288   arg1 = (Dali::Matrix3 *)jarg1;
12289   arg2 = (float)jarg2;
12290   {
12291     try {
12292       (arg1)->Scale(arg2);
12293     } catch (std::out_of_range& e) {
12294       {
12295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12296       };
12297     } catch (std::exception& e) {
12298       {
12299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12300       };
12301     } catch (...) {
12302       {
12303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12304       };
12305     }
12306   }
12307 }
12308
12309
12310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12311   float jresult ;
12312   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12313   float result;
12314
12315   arg1 = (Dali::Matrix3 *)jarg1;
12316   {
12317     try {
12318       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12319     } catch (std::out_of_range& e) {
12320       {
12321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (std::exception& e) {
12324       {
12325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (...) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12330       };
12331     }
12332   }
12333   jresult = result;
12334   return jresult;
12335 }
12336
12337
12338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12339   unsigned int jresult ;
12340   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12341   bool result;
12342
12343   arg1 = (Dali::Matrix3 *)jarg1;
12344   {
12345     try {
12346       result = (bool)(arg1)->ScaledInverseTranspose();
12347     } catch (std::out_of_range& e) {
12348       {
12349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12350       };
12351     } catch (std::exception& e) {
12352       {
12353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12354       };
12355     } catch (...) {
12356       {
12357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12358       };
12359     }
12360   }
12361   jresult = result;
12362   return jresult;
12363 }
12364
12365
12366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12367   Dali::Matrix3 *arg1 = 0 ;
12368   Dali::Matrix3 *arg2 = 0 ;
12369   Dali::Matrix3 *arg3 = 0 ;
12370
12371   arg1 = (Dali::Matrix3 *)jarg1;
12372   if (!arg1) {
12373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12374     return ;
12375   }
12376   arg2 = (Dali::Matrix3 *)jarg2;
12377   if (!arg2) {
12378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12379     return ;
12380   }
12381   arg3 = (Dali::Matrix3 *)jarg3;
12382   if (!arg3) {
12383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12384     return ;
12385   }
12386   {
12387     try {
12388       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12389     } catch (std::out_of_range& e) {
12390       {
12391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12392       };
12393     } catch (std::exception& e) {
12394       {
12395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12396       };
12397     } catch (...) {
12398       {
12399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12400       };
12401     }
12402   }
12403 }
12404
12405
12406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12407   float jresult ;
12408   float arg1 ;
12409   float arg2 ;
12410   float result;
12411
12412   arg1 = (float)jarg1;
12413   arg2 = (float)jarg2;
12414   {
12415     try {
12416       result = (float)Dali::Random::Range(arg1,arg2);
12417     } catch (std::out_of_range& e) {
12418       {
12419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12420       };
12421     } catch (std::exception& e) {
12422       {
12423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12424       };
12425     } catch (...) {
12426       {
12427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12428       };
12429     }
12430   }
12431   jresult = result;
12432   return jresult;
12433 }
12434
12435
12436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12437   void * jresult ;
12438   Dali::Vector4 result;
12439
12440   {
12441     try {
12442       result = Dali::Random::Axis();
12443     } catch (std::out_of_range& e) {
12444       {
12445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12446       };
12447     } catch (std::exception& e) {
12448       {
12449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12450       };
12451     } catch (...) {
12452       {
12453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12454       };
12455     }
12456   }
12457   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12458   return jresult;
12459 }
12460
12461
12462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12463   void * jresult ;
12464   Dali::AngleAxis *result = 0 ;
12465
12466   {
12467     try {
12468       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12469     } catch (std::out_of_range& e) {
12470       {
12471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12472       };
12473     } catch (std::exception& e) {
12474       {
12475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12480       };
12481     }
12482   }
12483   jresult = (void *)result;
12484   return jresult;
12485 }
12486
12487
12488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12489   void * jresult ;
12490   Dali::Radian arg1 ;
12491   Dali::Vector3 *arg2 = 0 ;
12492   Dali::Radian *argp1 ;
12493   Dali::AngleAxis *result = 0 ;
12494
12495   argp1 = (Dali::Radian *)jarg1;
12496   if (!argp1) {
12497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12498     return 0;
12499   }
12500   arg1 = *argp1;
12501   arg2 = (Dali::Vector3 *)jarg2;
12502   if (!arg2) {
12503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12504     return 0;
12505   }
12506   {
12507     try {
12508       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12509     } catch (std::out_of_range& e) {
12510       {
12511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12512       };
12513     } catch (std::exception& e) {
12514       {
12515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12516       };
12517     } catch (...) {
12518       {
12519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12520       };
12521     }
12522   }
12523   jresult = (void *)result;
12524   return jresult;
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12529   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12530   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12531
12532   arg1 = (Dali::AngleAxis *)jarg1;
12533   arg2 = (Dali::Radian *)jarg2;
12534   if (arg1) (arg1)->angle = *arg2;
12535 }
12536
12537
12538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12539   void * jresult ;
12540   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12541   Dali::Radian *result = 0 ;
12542
12543   arg1 = (Dali::AngleAxis *)jarg1;
12544   result = (Dali::Radian *)& ((arg1)->angle);
12545   jresult = (void *)result;
12546   return jresult;
12547 }
12548
12549
12550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12551   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12552   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12553
12554   arg1 = (Dali::AngleAxis *)jarg1;
12555   arg2 = (Dali::Vector3 *)jarg2;
12556   if (arg1) (arg1)->axis = *arg2;
12557 }
12558
12559
12560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12561   void * jresult ;
12562   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12563   Dali::Vector3 *result = 0 ;
12564
12565   arg1 = (Dali::AngleAxis *)jarg1;
12566   result = (Dali::Vector3 *)& ((arg1)->axis);
12567   jresult = (void *)result;
12568   return jresult;
12569 }
12570
12571
12572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12573   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12574
12575   arg1 = (Dali::AngleAxis *)jarg1;
12576   {
12577     try {
12578       delete arg1;
12579     } catch (std::out_of_range& e) {
12580       {
12581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12582       };
12583     } catch (std::exception& e) {
12584       {
12585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12586       };
12587     } catch (...) {
12588       {
12589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12590       };
12591     }
12592   }
12593 }
12594
12595
12596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12597   unsigned int jresult ;
12598   Dali::AngleAxis *arg1 = 0 ;
12599   Dali::AngleAxis *arg2 = 0 ;
12600   bool result;
12601
12602   arg1 = (Dali::AngleAxis *)jarg1;
12603   if (!arg1) {
12604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12605     return 0;
12606   }
12607   arg2 = (Dali::AngleAxis *)jarg2;
12608   if (!arg2) {
12609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12610     return 0;
12611   }
12612   {
12613     try {
12614       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12615     } catch (std::out_of_range& e) {
12616       {
12617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12618       };
12619     } catch (std::exception& e) {
12620       {
12621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12622       };
12623     } catch (...) {
12624       {
12625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12626       };
12627     }
12628   }
12629   jresult = result;
12630   return jresult;
12631 }
12632
12633
12634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12635   unsigned int jresult ;
12636   unsigned int arg1 ;
12637   unsigned int result;
12638
12639   arg1 = (unsigned int)jarg1;
12640   {
12641     try {
12642       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12643     } catch (std::out_of_range& e) {
12644       {
12645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12646       };
12647     } catch (std::exception& e) {
12648       {
12649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12650       };
12651     } catch (...) {
12652       {
12653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12654       };
12655     }
12656   }
12657   jresult = result;
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12663   unsigned int jresult ;
12664   unsigned int arg1 ;
12665   bool result;
12666
12667   arg1 = (unsigned int)jarg1;
12668   {
12669     try {
12670       result = (bool)Dali::IsPowerOfTwo(arg1);
12671     } catch (std::out_of_range& e) {
12672       {
12673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12674       };
12675     } catch (std::exception& e) {
12676       {
12677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12678       };
12679     } catch (...) {
12680       {
12681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12682       };
12683     }
12684   }
12685   jresult = result;
12686   return jresult;
12687 }
12688
12689
12690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12691   float jresult ;
12692   float arg1 ;
12693   float arg2 ;
12694   float result;
12695
12696   arg1 = (float)jarg1;
12697   arg2 = (float)jarg2;
12698   {
12699     try {
12700       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12701     } catch (std::out_of_range& e) {
12702       {
12703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12704       };
12705     } catch (std::exception& e) {
12706       {
12707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12708       };
12709     } catch (...) {
12710       {
12711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12712       };
12713     }
12714   }
12715   jresult = result;
12716   return jresult;
12717 }
12718
12719
12720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12721   unsigned int jresult ;
12722   float arg1 ;
12723   bool result;
12724
12725   arg1 = (float)jarg1;
12726   {
12727     try {
12728       result = (bool)Dali::EqualsZero(arg1);
12729     } catch (std::out_of_range& e) {
12730       {
12731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12732       };
12733     } catch (std::exception& e) {
12734       {
12735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12736       };
12737     } catch (...) {
12738       {
12739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12740       };
12741     }
12742   }
12743   jresult = result;
12744   return jresult;
12745 }
12746
12747
12748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12749   unsigned int jresult ;
12750   float arg1 ;
12751   float arg2 ;
12752   bool result;
12753
12754   arg1 = (float)jarg1;
12755   arg2 = (float)jarg2;
12756   {
12757     try {
12758       result = (bool)Dali::Equals(arg1,arg2);
12759     } catch (std::out_of_range& e) {
12760       {
12761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12762       };
12763     } catch (std::exception& e) {
12764       {
12765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12766       };
12767     } catch (...) {
12768       {
12769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12770       };
12771     }
12772   }
12773   jresult = result;
12774   return jresult;
12775 }
12776
12777
12778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12779   unsigned int jresult ;
12780   float arg1 ;
12781   float arg2 ;
12782   float arg3 ;
12783   bool result;
12784
12785   arg1 = (float)jarg1;
12786   arg2 = (float)jarg2;
12787   arg3 = (float)jarg3;
12788   {
12789     try {
12790       result = (bool)Dali::Equals(arg1,arg2,arg3);
12791     } catch (std::out_of_range& e) {
12792       {
12793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12794       };
12795     } catch (std::exception& e) {
12796       {
12797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12798       };
12799     } catch (...) {
12800       {
12801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12802       };
12803     }
12804   }
12805   jresult = result;
12806   return jresult;
12807 }
12808
12809
12810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12811   float jresult ;
12812   float arg1 ;
12813   int arg2 ;
12814   float result;
12815
12816   arg1 = (float)jarg1;
12817   arg2 = (int)jarg2;
12818   {
12819     try {
12820       result = (float)Dali::Round(arg1,arg2);
12821     } catch (std::out_of_range& e) {
12822       {
12823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12824       };
12825     } catch (std::exception& e) {
12826       {
12827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12828       };
12829     } catch (...) {
12830       {
12831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12832       };
12833     }
12834   }
12835   jresult = result;
12836   return jresult;
12837 }
12838
12839
12840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12841   float jresult ;
12842   float arg1 ;
12843   float arg2 ;
12844   float arg3 ;
12845   float result;
12846
12847   arg1 = (float)jarg1;
12848   arg2 = (float)jarg2;
12849   arg3 = (float)jarg3;
12850   {
12851     try {
12852       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12853     } catch (std::out_of_range& e) {
12854       {
12855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12856       };
12857     } catch (std::exception& e) {
12858       {
12859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12860       };
12861     } catch (...) {
12862       {
12863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12864       };
12865     }
12866   }
12867   jresult = result;
12868   return jresult;
12869 }
12870
12871
12872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12873   float jresult ;
12874   float arg1 ;
12875   float arg2 ;
12876   float arg3 ;
12877   float arg4 ;
12878   float result;
12879
12880   arg1 = (float)jarg1;
12881   arg2 = (float)jarg2;
12882   arg3 = (float)jarg3;
12883   arg4 = (float)jarg4;
12884   {
12885     try {
12886       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12887     } catch (std::out_of_range& e) {
12888       {
12889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12890       };
12891     } catch (std::exception& e) {
12892       {
12893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12898       };
12899     }
12900   }
12901   jresult = result;
12902   return jresult;
12903 }
12904
12905
12906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12907   int jresult ;
12908   int result;
12909
12910   result = (int)(int)Dali::Property::INVALID_INDEX;
12911   jresult = result;
12912   return jresult;
12913 }
12914
12915
12916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12917   int jresult ;
12918   int result;
12919
12920   result = (int)(int)Dali::Property::INVALID_KEY;
12921   jresult = result;
12922   return jresult;
12923 }
12924
12925
12926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12927   int jresult ;
12928   int result;
12929
12930   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12931   jresult = result;
12932   return jresult;
12933 }
12934
12935
12936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12937   void * jresult ;
12938   Dali::Handle *arg1 = 0 ;
12939   Dali::Property::Index arg2 ;
12940   Dali::Property *result = 0 ;
12941
12942   arg1 = (Dali::Handle *)jarg1;
12943   if (!arg1) {
12944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12945     return 0;
12946   }
12947   arg2 = (Dali::Property::Index)jarg2;
12948   {
12949     try {
12950       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12951     } catch (std::out_of_range& e) {
12952       {
12953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12954       };
12955     } catch (std::exception& e) {
12956       {
12957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12958       };
12959     } catch (...) {
12960       {
12961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12962       };
12963     }
12964   }
12965   jresult = (void *)result;
12966   return jresult;
12967 }
12968
12969
12970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12971   void * jresult ;
12972   Dali::Handle *arg1 = 0 ;
12973   Dali::Property::Index arg2 ;
12974   int arg3 ;
12975   Dali::Property *result = 0 ;
12976
12977   arg1 = (Dali::Handle *)jarg1;
12978   if (!arg1) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12980     return 0;
12981   }
12982   arg2 = (Dali::Property::Index)jarg2;
12983   arg3 = (int)jarg3;
12984   {
12985     try {
12986       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12987     } catch (std::out_of_range& e) {
12988       {
12989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12990       };
12991     } catch (std::exception& e) {
12992       {
12993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12994       };
12995     } catch (...) {
12996       {
12997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12998       };
12999     }
13000   }
13001   jresult = (void *)result;
13002   return jresult;
13003 }
13004
13005
13006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13007   void * jresult ;
13008   Dali::Handle *arg1 = 0 ;
13009   std::string *arg2 = 0 ;
13010   Dali::Property *result = 0 ;
13011
13012   arg1 = (Dali::Handle *)jarg1;
13013   if (!arg1) {
13014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13015     return 0;
13016   }
13017   if (!jarg2) {
13018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13019     return 0;
13020   }
13021   std::string arg2_str(jarg2);
13022   arg2 = &arg2_str;
13023   {
13024     try {
13025       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13026     } catch (std::out_of_range& e) {
13027       {
13028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13029       };
13030     } catch (std::exception& e) {
13031       {
13032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13033       };
13034     } catch (...) {
13035       {
13036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13037       };
13038     }
13039   }
13040   jresult = (void *)result;
13041
13042   //argout typemap for const std::string&
13043
13044   return jresult;
13045 }
13046
13047
13048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13049   void * jresult ;
13050   Dali::Handle *arg1 = 0 ;
13051   std::string *arg2 = 0 ;
13052   int arg3 ;
13053   Dali::Property *result = 0 ;
13054
13055   arg1 = (Dali::Handle *)jarg1;
13056   if (!arg1) {
13057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13058     return 0;
13059   }
13060   if (!jarg2) {
13061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13062     return 0;
13063   }
13064   std::string arg2_str(jarg2);
13065   arg2 = &arg2_str;
13066   arg3 = (int)jarg3;
13067   {
13068     try {
13069       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (...) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13081       };
13082     }
13083   }
13084   jresult = (void *)result;
13085
13086   //argout typemap for const std::string&
13087
13088   return jresult;
13089 }
13090
13091
13092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13093   Dali::Property *arg1 = (Dali::Property *) 0 ;
13094
13095   arg1 = (Dali::Property *)jarg1;
13096   {
13097     try {
13098       delete arg1;
13099     } catch (std::out_of_range& e) {
13100       {
13101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13102       };
13103     } catch (std::exception& e) {
13104       {
13105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13106       };
13107     } catch (...) {
13108       {
13109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13110       };
13111     }
13112   }
13113 }
13114
13115
13116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13117   Dali::Property *arg1 = (Dali::Property *) 0 ;
13118   Dali::Handle *arg2 = 0 ;
13119
13120   arg1 = (Dali::Property *)jarg1;
13121   arg2 = (Dali::Handle *)jarg2;
13122   if (!arg2) {
13123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13124     return ;
13125   }
13126   if (arg1) (arg1)->object = *arg2;
13127 }
13128
13129
13130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13131   void * jresult ;
13132   Dali::Property *arg1 = (Dali::Property *) 0 ;
13133   Dali::Handle *result = 0 ;
13134
13135   arg1 = (Dali::Property *)jarg1;
13136   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13137   jresult = (void *)result;
13138   return jresult;
13139 }
13140
13141
13142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13143   Dali::Property *arg1 = (Dali::Property *) 0 ;
13144   Dali::Property::Index arg2 ;
13145
13146   arg1 = (Dali::Property *)jarg1;
13147   arg2 = (Dali::Property::Index)jarg2;
13148   if (arg1) (arg1)->propertyIndex = arg2;
13149 }
13150
13151
13152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13153   int jresult ;
13154   Dali::Property *arg1 = (Dali::Property *) 0 ;
13155   Dali::Property::Index result;
13156
13157   arg1 = (Dali::Property *)jarg1;
13158   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13159   jresult = result;
13160   return jresult;
13161 }
13162
13163
13164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13165   Dali::Property *arg1 = (Dali::Property *) 0 ;
13166   int arg2 ;
13167
13168   arg1 = (Dali::Property *)jarg1;
13169   arg2 = (int)jarg2;
13170   if (arg1) (arg1)->componentIndex = arg2;
13171 }
13172
13173
13174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13175   int jresult ;
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177   int result;
13178
13179   arg1 = (Dali::Property *)jarg1;
13180   result = (int) ((arg1)->componentIndex);
13181   jresult = result;
13182   return jresult;
13183 }
13184
13185
13186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13187   void * jresult ;
13188   Dali::Property::Array *result = 0 ;
13189
13190   {
13191     try {
13192       result = (Dali::Property::Array *)new Dali::Property::Array();
13193     } catch (std::out_of_range& e) {
13194       {
13195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13196       };
13197     } catch (std::exception& e) {
13198       {
13199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13200       };
13201     } catch (...) {
13202       {
13203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13204       };
13205     }
13206   }
13207   jresult = (void *)result;
13208   return jresult;
13209 }
13210
13211
13212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13213   void * jresult ;
13214   Dali::Property::Array *arg1 = 0 ;
13215   Dali::Property::Array *result = 0 ;
13216
13217   arg1 = (Dali::Property::Array *)jarg1;
13218   if (!arg1) {
13219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13220     return 0;
13221   }
13222   {
13223     try {
13224       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13225     } catch (std::out_of_range& e) {
13226       {
13227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13228       };
13229     } catch (std::exception& e) {
13230       {
13231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13232       };
13233     } catch (...) {
13234       {
13235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13236       };
13237     }
13238   }
13239   jresult = (void *)result;
13240   return jresult;
13241 }
13242
13243
13244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13246
13247   arg1 = (Dali::Property::Array *)jarg1;
13248   {
13249     try {
13250       delete arg1;
13251     } catch (std::out_of_range& e) {
13252       {
13253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13254       };
13255     } catch (std::exception& e) {
13256       {
13257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13258       };
13259     } catch (...) {
13260       {
13261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13262       };
13263     }
13264   }
13265 }
13266
13267
13268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13269   unsigned long jresult ;
13270   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13271   Dali::Property::Array::SizeType result;
13272
13273   arg1 = (Dali::Property::Array *)jarg1;
13274   {
13275     try {
13276       result = ((Dali::Property::Array const *)arg1)->Size();
13277     } catch (std::out_of_range& e) {
13278       {
13279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13280       };
13281     } catch (std::exception& e) {
13282       {
13283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13284       };
13285     } catch (...) {
13286       {
13287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13288       };
13289     }
13290   }
13291   jresult = (unsigned long)result;
13292   return jresult;
13293 }
13294
13295
13296 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13297   unsigned long jresult ;
13298   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13299   Dali::Property::Array::SizeType result;
13300
13301   arg1 = (Dali::Property::Array *)jarg1;
13302   {
13303     try {
13304       result = ((Dali::Property::Array const *)arg1)->Count();
13305     } catch (std::out_of_range& e) {
13306       {
13307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13308       };
13309     } catch (std::exception& e) {
13310       {
13311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13312       };
13313     } catch (...) {
13314       {
13315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13316       };
13317     }
13318   }
13319   jresult = (unsigned long)result;
13320   return jresult;
13321 }
13322
13323
13324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13325   unsigned int jresult ;
13326   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13327   bool result;
13328
13329   arg1 = (Dali::Property::Array *)jarg1;
13330   {
13331     try {
13332       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13333     } catch (std::out_of_range& e) {
13334       {
13335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13336       };
13337     } catch (std::exception& e) {
13338       {
13339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13340       };
13341     } catch (...) {
13342       {
13343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13344       };
13345     }
13346   }
13347   jresult = result;
13348   return jresult;
13349 }
13350
13351
13352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13353   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13354
13355   arg1 = (Dali::Property::Array *)jarg1;
13356   {
13357     try {
13358       (arg1)->Clear();
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13366       };
13367     } catch (...) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13370       };
13371     }
13372   }
13373 }
13374
13375
13376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13377   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13378   Dali::Property::Array::SizeType arg2 ;
13379
13380   arg1 = (Dali::Property::Array *)jarg1;
13381   arg2 = (Dali::Property::Array::SizeType)jarg2;
13382   {
13383     try {
13384       (arg1)->Reserve(arg2);
13385     } catch (std::out_of_range& e) {
13386       {
13387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13388       };
13389     } catch (std::exception& e) {
13390       {
13391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13392       };
13393     } catch (...) {
13394       {
13395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13396       };
13397     }
13398   }
13399 }
13400
13401
13402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13403   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13404   Dali::Property::Array::SizeType arg2 ;
13405
13406   arg1 = (Dali::Property::Array *)jarg1;
13407   arg2 = (Dali::Property::Array::SizeType)jarg2;
13408   {
13409     try {
13410       (arg1)->Resize(arg2);
13411     } catch (std::out_of_range& e) {
13412       {
13413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13414       };
13415     } catch (std::exception& e) {
13416       {
13417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13418       };
13419     } catch (...) {
13420       {
13421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13422       };
13423     }
13424   }
13425 }
13426
13427
13428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13429   unsigned long jresult ;
13430   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13431   Dali::Property::Array::SizeType result;
13432
13433   arg1 = (Dali::Property::Array *)jarg1;
13434   {
13435     try {
13436       result = (arg1)->Capacity();
13437     } catch (std::out_of_range& e) {
13438       {
13439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13440       };
13441     } catch (std::exception& e) {
13442       {
13443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13444       };
13445     } catch (...) {
13446       {
13447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13448       };
13449     }
13450   }
13451   jresult = (unsigned long)result;
13452   return jresult;
13453 }
13454
13455
13456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13457   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13458   Dali::Property::Value *arg2 = 0 ;
13459
13460   arg1 = (Dali::Property::Array *)jarg1;
13461   arg2 = (Dali::Property::Value *)jarg2;
13462   if (!arg2) {
13463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13464     return ;
13465   }
13466   {
13467     try {
13468       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13469     } catch (std::out_of_range& e) {
13470       {
13471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13472       };
13473     } catch (std::exception& e) {
13474       {
13475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13476       };
13477     } catch (...) {
13478       {
13479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13480       };
13481     }
13482   }
13483 }
13484
13485
13486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13487   void * jresult ;
13488   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13489   Dali::Property::Value *arg2 = 0 ;
13490   Dali::Property::Array *result = 0 ;
13491
13492   arg1 = (Dali::Property::Array *)jarg1;
13493   arg2 = (Dali::Property::Value *)jarg2;
13494   if (!arg2) {
13495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13496     return 0;
13497   }
13498   {
13499     try {
13500       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13501     } catch (std::out_of_range& e) {
13502       {
13503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13504       };
13505     } catch (std::exception& e) {
13506       {
13507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13508       };
13509     } catch (...) {
13510       {
13511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13512       };
13513     }
13514   }
13515   jresult = (void *)result;
13516   return jresult;
13517 }
13518
13519
13520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13521   void * jresult ;
13522   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13523   Dali::Property::Array::SizeType arg2 ;
13524   Dali::Property::Value *result = 0 ;
13525
13526   arg1 = (Dali::Property::Array *)jarg1;
13527   arg2 = (Dali::Property::Array::SizeType)jarg2;
13528   {
13529     try {
13530       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13531     } catch (std::out_of_range& e) {
13532       {
13533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (std::exception& e) {
13536       {
13537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (...) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13542       };
13543     }
13544   }
13545   jresult = (void *)result;
13546   return jresult;
13547 }
13548
13549
13550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13551   void * jresult ;
13552   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13553   Dali::Property::Array::SizeType arg2 ;
13554   Dali::Property::Value *result = 0 ;
13555
13556   arg1 = (Dali::Property::Array *)jarg1;
13557   arg2 = (Dali::Property::Array::SizeType)jarg2;
13558   {
13559     try {
13560       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13561     } catch (std::out_of_range& e) {
13562       {
13563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13564       };
13565     } catch (std::exception& e) {
13566       {
13567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13568       };
13569     } catch (...) {
13570       {
13571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13572       };
13573     }
13574   }
13575   jresult = (void *)result;
13576   return jresult;
13577 }
13578
13579
13580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13581   void * jresult ;
13582   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13583   Dali::Property::Array *arg2 = 0 ;
13584   Dali::Property::Array *result = 0 ;
13585
13586   arg1 = (Dali::Property::Array *)jarg1;
13587   arg2 = (Dali::Property::Array *)jarg2;
13588   if (!arg2) {
13589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13590     return 0;
13591   }
13592   {
13593     try {
13594       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13595     } catch (std::out_of_range& e) {
13596       {
13597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13598       };
13599     } catch (std::exception& e) {
13600       {
13601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13602       };
13603     } catch (...) {
13604       {
13605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13606       };
13607     }
13608   }
13609   jresult = (void *)result;
13610   return jresult;
13611 }
13612
13613
13614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13615   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13616   enum Dali::Property::Key::Type arg2 ;
13617
13618   arg1 = (Dali::Property::Key *)jarg1;
13619   arg2 = (enum Dali::Property::Key::Type)jarg2;
13620   if (arg1) (arg1)->type = arg2;
13621 }
13622
13623
13624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13625   int jresult ;
13626   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13627   enum Dali::Property::Key::Type result;
13628
13629   arg1 = (Dali::Property::Key *)jarg1;
13630   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13631   jresult = (int)result;
13632   return jresult;
13633 }
13634
13635
13636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13637   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13638   Dali::Property::Index arg2 ;
13639
13640   arg1 = (Dali::Property::Key *)jarg1;
13641   arg2 = (Dali::Property::Index)jarg2;
13642   if (arg1) (arg1)->indexKey = arg2;
13643 }
13644
13645
13646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13647   int jresult ;
13648   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13649   Dali::Property::Index result;
13650
13651   arg1 = (Dali::Property::Key *)jarg1;
13652   result = (Dali::Property::Index) ((arg1)->indexKey);
13653   jresult = result;
13654   return jresult;
13655 }
13656
13657
13658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13659   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13660   std::string *arg2 = 0 ;
13661
13662   arg1 = (Dali::Property::Key *)jarg1;
13663   if (!jarg2) {
13664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13665     return ;
13666   }
13667   std::string arg2_str(jarg2);
13668   arg2 = &arg2_str;
13669   if (arg1) (arg1)->stringKey = *arg2;
13670
13671   //argout typemap for const std::string&
13672
13673 }
13674
13675
13676 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13677   char * jresult ;
13678   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13679   std::string *result = 0 ;
13680
13681   arg1 = (Dali::Property::Key *)jarg1;
13682   result = (std::string *) & ((arg1)->stringKey);
13683   jresult = SWIG_csharp_string_callback(result->c_str());
13684   return jresult;
13685 }
13686
13687
13688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13689   void * jresult ;
13690   std::string *arg1 = 0 ;
13691   Dali::Property::Key *result = 0 ;
13692
13693   if (!jarg1) {
13694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13695     return 0;
13696   }
13697   std::string arg1_str(jarg1);
13698   arg1 = &arg1_str;
13699   {
13700     try {
13701       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13702     } catch (std::out_of_range& e) {
13703       {
13704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13705       };
13706     } catch (std::exception& e) {
13707       {
13708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13709       };
13710     } catch (...) {
13711       {
13712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13713       };
13714     }
13715   }
13716   jresult = (void *)result;
13717
13718   //argout typemap for const std::string&
13719
13720   return jresult;
13721 }
13722
13723
13724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13725   void * jresult ;
13726   Dali::Property::Index arg1 ;
13727   Dali::Property::Key *result = 0 ;
13728
13729   arg1 = (Dali::Property::Index)jarg1;
13730   {
13731     try {
13732       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13733     } catch (std::out_of_range& e) {
13734       {
13735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13736       };
13737     } catch (std::exception& e) {
13738       {
13739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13740       };
13741     } catch (...) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13744       };
13745     }
13746   }
13747   jresult = (void *)result;
13748   return jresult;
13749 }
13750
13751
13752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13753   unsigned int jresult ;
13754   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13755   std::string *arg2 = 0 ;
13756   bool result;
13757
13758   arg1 = (Dali::Property::Key *)jarg1;
13759   if (!jarg2) {
13760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13761     return 0;
13762   }
13763   std::string arg2_str(jarg2);
13764   arg2 = &arg2_str;
13765   {
13766     try {
13767       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13768     } catch (std::out_of_range& e) {
13769       {
13770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13771       };
13772     } catch (std::exception& e) {
13773       {
13774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (...) {
13777       {
13778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13779       };
13780     }
13781   }
13782   jresult = result;
13783
13784   //argout typemap for const std::string&
13785
13786   return jresult;
13787 }
13788
13789
13790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13791   unsigned int jresult ;
13792   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13793   Dali::Property::Index arg2 ;
13794   bool result;
13795
13796   arg1 = (Dali::Property::Key *)jarg1;
13797   arg2 = (Dali::Property::Index)jarg2;
13798   {
13799     try {
13800       result = (bool)(arg1)->operator ==(arg2);
13801     } catch (std::out_of_range& e) {
13802       {
13803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13804       };
13805     } catch (std::exception& e) {
13806       {
13807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (...) {
13810       {
13811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13812       };
13813     }
13814   }
13815   jresult = result;
13816   return jresult;
13817 }
13818
13819
13820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13821   unsigned int jresult ;
13822   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13823   Dali::Property::Key *arg2 = 0 ;
13824   bool result;
13825
13826   arg1 = (Dali::Property::Key *)jarg1;
13827   arg2 = (Dali::Property::Key *)jarg2;
13828   if (!arg2) {
13829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13830     return 0;
13831   }
13832   {
13833     try {
13834       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13835     } catch (std::out_of_range& e) {
13836       {
13837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13838       };
13839     } catch (std::exception& e) {
13840       {
13841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13842       };
13843     } catch (...) {
13844       {
13845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13846       };
13847     }
13848   }
13849   jresult = result;
13850   return jresult;
13851 }
13852
13853
13854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13855   unsigned int jresult ;
13856   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13857   std::string *arg2 = 0 ;
13858   bool result;
13859
13860   arg1 = (Dali::Property::Key *)jarg1;
13861   if (!jarg2) {
13862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13863     return 0;
13864   }
13865   std::string arg2_str(jarg2);
13866   arg2 = &arg2_str;
13867   {
13868     try {
13869       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13870     } catch (std::out_of_range& e) {
13871       {
13872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13873       };
13874     } catch (std::exception& e) {
13875       {
13876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13877       };
13878     } catch (...) {
13879       {
13880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13881       };
13882     }
13883   }
13884   jresult = result;
13885
13886   //argout typemap for const std::string&
13887
13888   return jresult;
13889 }
13890
13891
13892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13893   unsigned int jresult ;
13894   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13895   Dali::Property::Index arg2 ;
13896   bool result;
13897
13898   arg1 = (Dali::Property::Key *)jarg1;
13899   arg2 = (Dali::Property::Index)jarg2;
13900   {
13901     try {
13902       result = (bool)(arg1)->operator !=(arg2);
13903     } catch (std::out_of_range& e) {
13904       {
13905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13906       };
13907     } catch (std::exception& e) {
13908       {
13909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13910       };
13911     } catch (...) {
13912       {
13913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13914       };
13915     }
13916   }
13917   jresult = result;
13918   return jresult;
13919 }
13920
13921
13922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13923   unsigned int jresult ;
13924   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13925   Dali::Property::Key *arg2 = 0 ;
13926   bool result;
13927
13928   arg1 = (Dali::Property::Key *)jarg1;
13929   arg2 = (Dali::Property::Key *)jarg2;
13930   if (!arg2) {
13931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13932     return 0;
13933   }
13934   {
13935     try {
13936       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13937     } catch (std::out_of_range& e) {
13938       {
13939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13940       };
13941     } catch (std::exception& e) {
13942       {
13943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13944       };
13945     } catch (...) {
13946       {
13947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13948       };
13949     }
13950   }
13951   jresult = result;
13952   return jresult;
13953 }
13954
13955
13956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13957   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13958
13959   arg1 = (Dali::Property::Key *)jarg1;
13960   {
13961     try {
13962       delete arg1;
13963     } catch (std::out_of_range& e) {
13964       {
13965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13966       };
13967     } catch (std::exception& e) {
13968       {
13969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13970       };
13971     } catch (...) {
13972       {
13973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13974       };
13975     }
13976   }
13977 }
13978
13979
13980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13981   void * jresult ;
13982   Dali::Property::Map *result = 0 ;
13983
13984   {
13985     try {
13986       result = (Dali::Property::Map *)new Dali::Property::Map();
13987     } catch (std::out_of_range& e) {
13988       {
13989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13990       };
13991     } catch (std::exception& e) {
13992       {
13993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13994       };
13995     } catch (...) {
13996       {
13997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13998       };
13999     }
14000   }
14001   jresult = (void *)result;
14002   return jresult;
14003 }
14004
14005
14006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14007   void * jresult ;
14008   Dali::Property::Map *arg1 = 0 ;
14009   Dali::Property::Map *result = 0 ;
14010
14011   arg1 = (Dali::Property::Map *)jarg1;
14012   if (!arg1) {
14013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14014     return 0;
14015   }
14016   {
14017     try {
14018       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14019     } catch (std::out_of_range& e) {
14020       {
14021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14022       };
14023     } catch (std::exception& e) {
14024       {
14025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (...) {
14028       {
14029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14030       };
14031     }
14032   }
14033   jresult = (void *)result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14039   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14040
14041   arg1 = (Dali::Property::Map *)jarg1;
14042   {
14043     try {
14044       delete arg1;
14045     } catch (std::out_of_range& e) {
14046       {
14047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14048       };
14049     } catch (std::exception& e) {
14050       {
14051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14052       };
14053     } catch (...) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14056       };
14057     }
14058   }
14059 }
14060
14061
14062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14063   unsigned long jresult ;
14064   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14065   Dali::Property::Map::SizeType result;
14066
14067   arg1 = (Dali::Property::Map *)jarg1;
14068   {
14069     try {
14070       result = ((Dali::Property::Map const *)arg1)->Count();
14071     } catch (std::out_of_range& e) {
14072       {
14073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14074       };
14075     } catch (std::exception& e) {
14076       {
14077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14078       };
14079     } catch (...) {
14080       {
14081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14082       };
14083     }
14084   }
14085   jresult = (unsigned long)result;
14086   return jresult;
14087 }
14088
14089
14090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14091   unsigned int jresult ;
14092   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14093   bool result;
14094
14095   arg1 = (Dali::Property::Map *)jarg1;
14096   {
14097     try {
14098       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14099     } catch (std::out_of_range& e) {
14100       {
14101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14102       };
14103     } catch (std::exception& e) {
14104       {
14105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14106       };
14107     } catch (...) {
14108       {
14109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14110       };
14111     }
14112   }
14113   jresult = result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14119   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14120   char *arg2 = (char *) 0 ;
14121   Dali::Property::Value *arg3 = 0 ;
14122
14123   arg1 = (Dali::Property::Map *)jarg1;
14124   arg2 = (char *)jarg2;
14125   arg3 = (Dali::Property::Value *)jarg3;
14126   if (!arg3) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14128     return ;
14129   }
14130   {
14131     try {
14132       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14133     } catch (std::out_of_range& e) {
14134       {
14135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14136       };
14137     } catch (std::exception& e) {
14138       {
14139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14140       };
14141     } catch (...) {
14142       {
14143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14144       };
14145     }
14146   }
14147 }
14148
14149
14150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14151   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14152   Dali::Property::Index arg2 ;
14153   Dali::Property::Value *arg3 = 0 ;
14154
14155   arg1 = (Dali::Property::Map *)jarg1;
14156   arg2 = (Dali::Property::Index)jarg2;
14157   arg3 = (Dali::Property::Value *)jarg3;
14158   if (!arg3) {
14159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14160     return ;
14161   }
14162   {
14163     try {
14164       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14165     } catch (std::out_of_range& e) {
14166       {
14167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14168       };
14169     } catch (std::exception& e) {
14170       {
14171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14172       };
14173     } catch (...) {
14174       {
14175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14176       };
14177     }
14178   }
14179 }
14180
14181
14182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14183   void * jresult ;
14184   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14185   char *arg2 = (char *) 0 ;
14186   Dali::Property::Value *arg3 = 0 ;
14187   Dali::Property::Map *result = 0 ;
14188
14189   arg1 = (Dali::Property::Map *)jarg1;
14190   arg2 = (char *)jarg2;
14191   arg3 = (Dali::Property::Value *)jarg3;
14192   if (!arg3) {
14193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14194     return 0;
14195   }
14196   {
14197     try {
14198       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14199     } catch (std::out_of_range& e) {
14200       {
14201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14202       };
14203     } catch (std::exception& e) {
14204       {
14205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (...) {
14208       {
14209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14210       };
14211     }
14212   }
14213   jresult = (void *)result;
14214   return jresult;
14215 }
14216
14217
14218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14219   void * jresult ;
14220   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14221   Dali::Property::Index arg2 ;
14222   Dali::Property::Value *arg3 = 0 ;
14223   Dali::Property::Map *result = 0 ;
14224
14225   arg1 = (Dali::Property::Map *)jarg1;
14226   arg2 = (Dali::Property::Index)jarg2;
14227   arg3 = (Dali::Property::Value *)jarg3;
14228   if (!arg3) {
14229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14230     return 0;
14231   }
14232   {
14233     try {
14234       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14235     } catch (std::out_of_range& e) {
14236       {
14237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14238       };
14239     } catch (std::exception& e) {
14240       {
14241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14242       };
14243     } catch (...) {
14244       {
14245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14246       };
14247     }
14248   }
14249   jresult = (void *)result;
14250   return jresult;
14251 }
14252
14253
14254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14255   void * jresult ;
14256   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14257   Dali::Property::Map::SizeType arg2 ;
14258   Dali::Property::Value *result = 0 ;
14259
14260   arg1 = (Dali::Property::Map *)jarg1;
14261   arg2 = (Dali::Property::Map::SizeType)jarg2;
14262   {
14263     try {
14264       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14265     } catch (std::out_of_range& e) {
14266       {
14267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14268       };
14269     } catch (std::exception& e) {
14270       {
14271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14272       };
14273     } catch (...) {
14274       {
14275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14276       };
14277     }
14278   }
14279   jresult = (void *)result;
14280   return jresult;
14281 }
14282
14283
14284 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14285   char * jresult ;
14286   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14287   Dali::Property::Map::SizeType arg2 ;
14288   std::string *result = 0 ;
14289
14290   arg1 = (Dali::Property::Map *)jarg1;
14291   arg2 = (Dali::Property::Map::SizeType)jarg2;
14292   {
14293     try {
14294       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14295     } catch (std::out_of_range& e) {
14296       {
14297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14298       };
14299     } catch (std::exception& e) {
14300       {
14301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14302       };
14303     } catch (...) {
14304       {
14305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14306       };
14307     }
14308   }
14309   jresult = SWIG_csharp_string_callback(result->c_str());
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14315   void * jresult ;
14316   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14317   Dali::Property::Map::SizeType arg2 ;
14318   SwigValueWrapper< Dali::Property::Key > result;
14319
14320   arg1 = (Dali::Property::Map *)jarg1;
14321   arg2 = (Dali::Property::Map::SizeType)jarg2;
14322   {
14323     try {
14324       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14325     } catch (std::out_of_range& e) {
14326       {
14327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (std::exception& e) {
14330       {
14331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14340   return jresult;
14341 }
14342
14343
14344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14345   void * jresult ;
14346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14347   Dali::Property::Map::SizeType arg2 ;
14348   StringValuePair *result = 0 ;
14349
14350   arg1 = (Dali::Property::Map *)jarg1;
14351   arg2 = (Dali::Property::Map::SizeType)jarg2;
14352   {
14353     try {
14354       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14355     } catch (std::out_of_range& e) {
14356       {
14357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (std::exception& e) {
14360       {
14361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369   jresult = (void *)result;
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14375   void * jresult ;
14376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14377   char *arg2 = (char *) 0 ;
14378   Dali::Property::Value *result = 0 ;
14379
14380   arg1 = (Dali::Property::Map *)jarg1;
14381   arg2 = (char *)jarg2;
14382   {
14383     try {
14384       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399   jresult = (void *)result;
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14405   void * jresult ;
14406   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14407   Dali::Property::Index arg2 ;
14408   Dali::Property::Value *result = 0 ;
14409
14410   arg1 = (Dali::Property::Map *)jarg1;
14411   arg2 = (Dali::Property::Index)jarg2;
14412   {
14413     try {
14414       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429   jresult = (void *)result;
14430   return jresult;
14431 }
14432
14433
14434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14435   void * jresult ;
14436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14437   Dali::Property::Index arg2 ;
14438   std::string *arg3 = 0 ;
14439   Dali::Property::Value *result = 0 ;
14440
14441   arg1 = (Dali::Property::Map *)jarg1;
14442   arg2 = (Dali::Property::Index)jarg2;
14443   if (!jarg3) {
14444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14445     return 0;
14446   }
14447   std::string arg3_str(jarg3);
14448   arg3 = &arg3_str;
14449   {
14450     try {
14451       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14452     } catch (std::out_of_range& e) {
14453       {
14454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (std::exception& e) {
14457       {
14458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (...) {
14461       {
14462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14463       };
14464     }
14465   }
14466   jresult = (void *)result;
14467
14468   //argout typemap for const std::string&
14469
14470   return jresult;
14471 }
14472
14473
14474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14475   void * jresult ;
14476   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14477   std::string *arg2 = 0 ;
14478   Dali::Property::Type arg3 ;
14479   Dali::Property::Value *result = 0 ;
14480
14481   arg1 = (Dali::Property::Map *)jarg1;
14482   if (!jarg2) {
14483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14484     return 0;
14485   }
14486   std::string arg2_str(jarg2);
14487   arg2 = &arg2_str;
14488   arg3 = (Dali::Property::Type)jarg3;
14489   {
14490     try {
14491       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14492     } catch (std::out_of_range& e) {
14493       {
14494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14495       };
14496     } catch (std::exception& e) {
14497       {
14498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14499       };
14500     } catch (...) {
14501       {
14502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14503       };
14504     }
14505   }
14506   jresult = (void *)result;
14507
14508   //argout typemap for const std::string&
14509
14510   return jresult;
14511 }
14512
14513
14514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14515   void * jresult ;
14516   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14517   Dali::Property::Index arg2 ;
14518   Dali::Property::Type arg3 ;
14519   Dali::Property::Value *result = 0 ;
14520
14521   arg1 = (Dali::Property::Map *)jarg1;
14522   arg2 = (Dali::Property::Index)jarg2;
14523   arg3 = (Dali::Property::Type)jarg3;
14524   {
14525     try {
14526       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14527     } catch (std::out_of_range& e) {
14528       {
14529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14530       };
14531     } catch (std::exception& e) {
14532       {
14533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14534       };
14535     } catch (...) {
14536       {
14537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14538       };
14539     }
14540   }
14541   jresult = (void *)result;
14542   return jresult;
14543 }
14544
14545
14546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14547   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14548
14549   arg1 = (Dali::Property::Map *)jarg1;
14550   {
14551     try {
14552       (arg1)->Clear();
14553     } catch (std::out_of_range& e) {
14554       {
14555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14556       };
14557     } catch (std::exception& e) {
14558       {
14559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14560       };
14561     } catch (...) {
14562       {
14563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14564       };
14565     }
14566   }
14567 }
14568
14569
14570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14571   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14572   Dali::Property::Map *arg2 = 0 ;
14573
14574   arg1 = (Dali::Property::Map *)jarg1;
14575   arg2 = (Dali::Property::Map *)jarg2;
14576   if (!arg2) {
14577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14578     return ;
14579   }
14580   {
14581     try {
14582       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14583     } catch (std::out_of_range& e) {
14584       {
14585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14586       };
14587     } catch (std::exception& e) {
14588       {
14589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14590       };
14591     } catch (...) {
14592       {
14593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14594       };
14595     }
14596   }
14597 }
14598
14599
14600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14601   void * jresult ;
14602   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14603   std::string *arg2 = 0 ;
14604   Dali::Property::Value *result = 0 ;
14605
14606   arg1 = (Dali::Property::Map *)jarg1;
14607   if (!jarg2) {
14608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14609     return 0;
14610   }
14611   std::string arg2_str(jarg2);
14612   arg2 = &arg2_str;
14613   {
14614     try {
14615       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14616     } catch (std::out_of_range& e) {
14617       {
14618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14619       };
14620     } catch (std::exception& e) {
14621       {
14622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14623       };
14624     } catch (...) {
14625       {
14626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14627       };
14628     }
14629   }
14630   jresult = (void *)result;
14631
14632   //argout typemap for const std::string&
14633
14634   return jresult;
14635 }
14636
14637
14638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14639   void * jresult ;
14640   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14641   Dali::Property::Index arg2 ;
14642   Dali::Property::Value *result = 0 ;
14643
14644   arg1 = (Dali::Property::Map *)jarg1;
14645   arg2 = (Dali::Property::Index)jarg2;
14646   {
14647     try {
14648       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14649     } catch (std::out_of_range& e) {
14650       {
14651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14652       };
14653     } catch (std::exception& e) {
14654       {
14655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14656       };
14657     } catch (...) {
14658       {
14659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14660       };
14661     }
14662   }
14663   jresult = (void *)result;
14664   return jresult;
14665 }
14666
14667
14668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14669   void * jresult ;
14670   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14671   Dali::Property::Map *arg2 = 0 ;
14672   Dali::Property::Map *result = 0 ;
14673
14674   arg1 = (Dali::Property::Map *)jarg1;
14675   arg2 = (Dali::Property::Map *)jarg2;
14676   if (!arg2) {
14677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14678     return 0;
14679   }
14680   {
14681     try {
14682       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14683     } catch (std::out_of_range& e) {
14684       {
14685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14686       };
14687     } catch (std::exception& e) {
14688       {
14689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14690       };
14691     } catch (...) {
14692       {
14693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14694       };
14695     }
14696   }
14697   jresult = (void *)result;
14698   return jresult;
14699 }
14700
14701
14702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14703   void * jresult ;
14704   Dali::Property::Value *result = 0 ;
14705
14706   {
14707     try {
14708       result = (Dali::Property::Value *)new Dali::Property::Value();
14709     } catch (std::out_of_range& e) {
14710       {
14711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (std::exception& e) {
14714       {
14715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723   jresult = (void *)result;
14724   return jresult;
14725 }
14726
14727
14728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14729   void * jresult ;
14730   bool arg1 ;
14731   Dali::Property::Value *result = 0 ;
14732
14733   arg1 = jarg1 ? true : false;
14734   {
14735     try {
14736       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14737     } catch (std::out_of_range& e) {
14738       {
14739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14740       };
14741     } catch (std::exception& e) {
14742       {
14743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14744       };
14745     } catch (...) {
14746       {
14747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14748       };
14749     }
14750   }
14751   jresult = (void *)result;
14752   return jresult;
14753 }
14754
14755
14756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14757   void * jresult ;
14758   int arg1 ;
14759   Dali::Property::Value *result = 0 ;
14760
14761   arg1 = (int)jarg1;
14762   {
14763     try {
14764       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14765     } catch (std::out_of_range& e) {
14766       {
14767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14768       };
14769     } catch (std::exception& e) {
14770       {
14771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (...) {
14774       {
14775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14776       };
14777     }
14778   }
14779   jresult = (void *)result;
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14785   void * jresult ;
14786   float arg1 ;
14787   Dali::Property::Value *result = 0 ;
14788
14789   arg1 = (float)jarg1;
14790   {
14791     try {
14792       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14793     } catch (std::out_of_range& e) {
14794       {
14795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14796       };
14797     } catch (std::exception& e) {
14798       {
14799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14800       };
14801     } catch (...) {
14802       {
14803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14804       };
14805     }
14806   }
14807   jresult = (void *)result;
14808   return jresult;
14809 }
14810
14811
14812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14813   void * jresult ;
14814   Dali::Vector2 *arg1 = 0 ;
14815   Dali::Property::Value *result = 0 ;
14816
14817   arg1 = (Dali::Vector2 *)jarg1;
14818   if (!arg1) {
14819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14820     return 0;
14821   }
14822   {
14823     try {
14824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14825     } catch (std::out_of_range& e) {
14826       {
14827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14828       };
14829     } catch (std::exception& e) {
14830       {
14831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (...) {
14834       {
14835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14836       };
14837     }
14838   }
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14845   void * jresult ;
14846   Dali::Vector3 *arg1 = 0 ;
14847   Dali::Property::Value *result = 0 ;
14848
14849   arg1 = (Dali::Vector3 *)jarg1;
14850   if (!arg1) {
14851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14852     return 0;
14853   }
14854   {
14855     try {
14856       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14857     } catch (std::out_of_range& e) {
14858       {
14859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (std::exception& e) {
14862       {
14863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14864       };
14865     } catch (...) {
14866       {
14867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14868       };
14869     }
14870   }
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14877   void * jresult ;
14878   Dali::Vector4 *arg1 = 0 ;
14879   Dali::Property::Value *result = 0 ;
14880
14881   arg1 = (Dali::Vector4 *)jarg1;
14882   if (!arg1) {
14883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14884     return 0;
14885   }
14886   {
14887     try {
14888       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14889     } catch (std::out_of_range& e) {
14890       {
14891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (std::exception& e) {
14894       {
14895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (...) {
14898       {
14899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14900       };
14901     }
14902   }
14903   jresult = (void *)result;
14904   return jresult;
14905 }
14906
14907
14908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14909   void * jresult ;
14910   Dali::Matrix3 *arg1 = 0 ;
14911   Dali::Property::Value *result = 0 ;
14912
14913   arg1 = (Dali::Matrix3 *)jarg1;
14914   if (!arg1) {
14915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14916     return 0;
14917   }
14918   {
14919     try {
14920       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14921     } catch (std::out_of_range& e) {
14922       {
14923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14924       };
14925     } catch (std::exception& e) {
14926       {
14927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14928       };
14929     } catch (...) {
14930       {
14931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14932       };
14933     }
14934   }
14935   jresult = (void *)result;
14936   return jresult;
14937 }
14938
14939
14940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14941   void * jresult ;
14942   Dali::Matrix *arg1 = 0 ;
14943   Dali::Property::Value *result = 0 ;
14944
14945   arg1 = (Dali::Matrix *)jarg1;
14946   if (!arg1) {
14947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14948     return 0;
14949   }
14950   {
14951     try {
14952       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14953     } catch (std::out_of_range& e) {
14954       {
14955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (std::exception& e) {
14958       {
14959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14960       };
14961     } catch (...) {
14962       {
14963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14964       };
14965     }
14966   }
14967   jresult = (void *)result;
14968   return jresult;
14969 }
14970
14971
14972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14973   void * jresult ;
14974   Dali::Rect< int > *arg1 = 0 ;
14975   Dali::Property::Value *result = 0 ;
14976
14977   arg1 = (Dali::Rect< int > *)jarg1;
14978   if (!arg1) {
14979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14980     return 0;
14981   }
14982   {
14983     try {
14984       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14985     } catch (std::out_of_range& e) {
14986       {
14987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14988       };
14989     } catch (std::exception& e) {
14990       {
14991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (...) {
14994       {
14995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14996       };
14997     }
14998   }
14999   jresult = (void *)result;
15000   return jresult;
15001 }
15002
15003
15004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15005   void * jresult ;
15006   Dali::AngleAxis *arg1 = 0 ;
15007   Dali::Property::Value *result = 0 ;
15008
15009   arg1 = (Dali::AngleAxis *)jarg1;
15010   if (!arg1) {
15011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15012     return 0;
15013   }
15014   {
15015     try {
15016       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15017     } catch (std::out_of_range& e) {
15018       {
15019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (std::exception& e) {
15022       {
15023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (...) {
15026       {
15027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15028       };
15029     }
15030   }
15031   jresult = (void *)result;
15032   return jresult;
15033 }
15034
15035
15036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15037   void * jresult ;
15038   Dali::Quaternion *arg1 = 0 ;
15039   Dali::Property::Value *result = 0 ;
15040
15041   arg1 = (Dali::Quaternion *)jarg1;
15042   if (!arg1) {
15043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15044     return 0;
15045   }
15046   {
15047     try {
15048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15049     } catch (std::out_of_range& e) {
15050       {
15051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15052       };
15053     } catch (std::exception& e) {
15054       {
15055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15056       };
15057     } catch (...) {
15058       {
15059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15060       };
15061     }
15062   }
15063   jresult = (void *)result;
15064   return jresult;
15065 }
15066
15067
15068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15069   void * jresult ;
15070   std::string *arg1 = 0 ;
15071   Dali::Property::Value *result = 0 ;
15072
15073   if (!jarg1) {
15074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15075     return 0;
15076   }
15077   std::string arg1_str(jarg1);
15078   arg1 = &arg1_str;
15079   {
15080     try {
15081       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15082     } catch (std::out_of_range& e) {
15083       {
15084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15085       };
15086     } catch (std::exception& e) {
15087       {
15088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15089       };
15090     } catch (...) {
15091       {
15092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15093       };
15094     }
15095   }
15096   jresult = (void *)result;
15097
15098   //argout typemap for const std::string&
15099
15100   return jresult;
15101 }
15102
15103
15104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15105   void * jresult ;
15106   Dali::Property::Array *arg1 = 0 ;
15107   Dali::Property::Value *result = 0 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   if (!arg1) {
15111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15112     return 0;
15113   }
15114   {
15115     try {
15116       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15117     } catch (std::out_of_range& e) {
15118       {
15119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15120       };
15121     } catch (std::exception& e) {
15122       {
15123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15124       };
15125     } catch (...) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15128       };
15129     }
15130   }
15131   jresult = (void *)result;
15132   return jresult;
15133 }
15134
15135
15136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15137   void * jresult ;
15138   Dali::Property::Map *arg1 = 0 ;
15139   Dali::Property::Value *result = 0 ;
15140
15141   arg1 = (Dali::Property::Map *)jarg1;
15142   if (!arg1) {
15143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15144     return 0;
15145   }
15146   {
15147     try {
15148       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15149     } catch (std::out_of_range& e) {
15150       {
15151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (std::exception& e) {
15154       {
15155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15160       };
15161     }
15162   }
15163   jresult = (void *)result;
15164   return jresult;
15165 }
15166
15167
15168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15169   void * jresult ;
15170   Dali::Property::Type arg1 ;
15171   Dali::Property::Value *result = 0 ;
15172
15173   arg1 = (Dali::Property::Type)jarg1;
15174   {
15175     try {
15176       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (...) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15188       };
15189     }
15190   }
15191   jresult = (void *)result;
15192   return jresult;
15193 }
15194
15195
15196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15197   void * jresult ;
15198   Dali::Property::Value *arg1 = 0 ;
15199   Dali::Property::Value *result = 0 ;
15200
15201   arg1 = (Dali::Property::Value *)jarg1;
15202   if (!arg1) {
15203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15204     return 0;
15205   }
15206   {
15207     try {
15208       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15209     } catch (std::out_of_range& e) {
15210       {
15211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15212       };
15213     } catch (std::exception& e) {
15214       {
15215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15216       };
15217     } catch (...) {
15218       {
15219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15220       };
15221     }
15222   }
15223   jresult = (void *)result;
15224   return jresult;
15225 }
15226
15227
15228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15229   void * jresult ;
15230   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15231   Dali::Property::Value *arg2 = 0 ;
15232   Dali::Property::Value *result = 0 ;
15233
15234   arg1 = (Dali::Property::Value *)jarg1;
15235   arg2 = (Dali::Property::Value *)jarg2;
15236   if (!arg2) {
15237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15238     return 0;
15239   }
15240   {
15241     try {
15242       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15243     } catch (std::out_of_range& e) {
15244       {
15245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15246       };
15247     } catch (std::exception& e) {
15248       {
15249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15250       };
15251     } catch (...) {
15252       {
15253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15254       };
15255     }
15256   }
15257   jresult = (void *)result;
15258   return jresult;
15259 }
15260
15261
15262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15263   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15264
15265   arg1 = (Dali::Property::Value *)jarg1;
15266   {
15267     try {
15268       delete arg1;
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15280       };
15281     }
15282   }
15283 }
15284
15285
15286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15287   int jresult ;
15288   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15289   Dali::Property::Type result;
15290
15291   arg1 = (Dali::Property::Value *)jarg1;
15292   {
15293     try {
15294       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15295     } catch (std::out_of_range& e) {
15296       {
15297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15298       };
15299     } catch (std::exception& e) {
15300       {
15301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (...) {
15304       {
15305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15306       };
15307     }
15308   }
15309   jresult = (int)result;
15310   return jresult;
15311 }
15312
15313
15314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15315   unsigned int jresult ;
15316   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15317   bool *arg2 = 0 ;
15318   bool result;
15319
15320   arg1 = (Dali::Property::Value *)jarg1;
15321   arg2 = (bool *)jarg2;
15322   {
15323     try {
15324       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15325     } catch (std::out_of_range& e) {
15326       {
15327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15328       };
15329     } catch (std::exception& e) {
15330       {
15331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15332       };
15333     } catch (...) {
15334       {
15335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15336       };
15337     }
15338   }
15339   jresult = result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15345   unsigned int jresult ;
15346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15347   float *arg2 = 0 ;
15348   bool result;
15349
15350   arg1 = (Dali::Property::Value *)jarg1;
15351   arg2 = (float *)jarg2;
15352   {
15353     try {
15354       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15355     } catch (std::out_of_range& e) {
15356       {
15357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (std::exception& e) {
15360       {
15361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (...) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15366       };
15367     }
15368   }
15369   jresult = result;
15370   return jresult;
15371 }
15372
15373
15374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15375   unsigned int jresult ;
15376   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15377   int *arg2 = 0 ;
15378   bool result;
15379
15380   arg1 = (Dali::Property::Value *)jarg1;
15381   arg2 = (int *)jarg2;
15382   {
15383     try {
15384       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15385     } catch (std::out_of_range& e) {
15386       {
15387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15388       };
15389     } catch (std::exception& e) {
15390       {
15391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15392       };
15393     } catch (...) {
15394       {
15395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15396       };
15397     }
15398   }
15399   jresult = result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15405   unsigned int jresult ;
15406   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15407   Dali::Rect< int > *arg2 = 0 ;
15408   bool result;
15409
15410   arg1 = (Dali::Property::Value *)jarg1;
15411   arg2 = (Dali::Rect< int > *)jarg2;
15412   if (!arg2) {
15413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15414     return 0;
15415   }
15416   {
15417     try {
15418       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15419     } catch (std::out_of_range& e) {
15420       {
15421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15422       };
15423     } catch (std::exception& e) {
15424       {
15425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15426       };
15427     } catch (...) {
15428       {
15429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15430       };
15431     }
15432   }
15433   jresult = result;
15434   return jresult;
15435 }
15436
15437
15438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15439   unsigned int jresult ;
15440   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15441   Dali::Vector2 *arg2 = 0 ;
15442   bool result;
15443
15444   arg1 = (Dali::Property::Value *)jarg1;
15445   arg2 = (Dali::Vector2 *)jarg2;
15446   if (!arg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15448     return 0;
15449   }
15450   {
15451     try {
15452       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15453     } catch (std::out_of_range& e) {
15454       {
15455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15456       };
15457     } catch (std::exception& e) {
15458       {
15459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15460       };
15461     } catch (...) {
15462       {
15463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15464       };
15465     }
15466   }
15467   jresult = result;
15468   return jresult;
15469 }
15470
15471
15472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15473   unsigned int jresult ;
15474   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15475   Dali::Vector3 *arg2 = 0 ;
15476   bool result;
15477
15478   arg1 = (Dali::Property::Value *)jarg1;
15479   arg2 = (Dali::Vector3 *)jarg2;
15480   if (!arg2) {
15481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15482     return 0;
15483   }
15484   {
15485     try {
15486       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (...) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15498       };
15499     }
15500   }
15501   jresult = result;
15502   return jresult;
15503 }
15504
15505
15506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15507   unsigned int jresult ;
15508   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15509   Dali::Vector4 *arg2 = 0 ;
15510   bool result;
15511
15512   arg1 = (Dali::Property::Value *)jarg1;
15513   arg2 = (Dali::Vector4 *)jarg2;
15514   if (!arg2) {
15515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15516     return 0;
15517   }
15518   {
15519     try {
15520       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (...) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15532       };
15533     }
15534   }
15535   jresult = result;
15536   return jresult;
15537 }
15538
15539
15540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15541   unsigned int jresult ;
15542   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15543   Dali::Matrix3 *arg2 = 0 ;
15544   bool result;
15545
15546   arg1 = (Dali::Property::Value *)jarg1;
15547   arg2 = (Dali::Matrix3 *)jarg2;
15548   if (!arg2) {
15549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15550     return 0;
15551   }
15552   {
15553     try {
15554       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15555     } catch (std::out_of_range& e) {
15556       {
15557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15558       };
15559     } catch (std::exception& e) {
15560       {
15561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15562       };
15563     } catch (...) {
15564       {
15565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15566       };
15567     }
15568   }
15569   jresult = result;
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15575   unsigned int jresult ;
15576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15577   Dali::Matrix *arg2 = 0 ;
15578   bool result;
15579
15580   arg1 = (Dali::Property::Value *)jarg1;
15581   arg2 = (Dali::Matrix *)jarg2;
15582   if (!arg2) {
15583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15584     return 0;
15585   }
15586   {
15587     try {
15588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15589     } catch (std::out_of_range& e) {
15590       {
15591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15592       };
15593     } catch (std::exception& e) {
15594       {
15595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (...) {
15598       {
15599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15600       };
15601     }
15602   }
15603   jresult = result;
15604   return jresult;
15605 }
15606
15607
15608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15609   unsigned int jresult ;
15610   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15611   Dali::AngleAxis *arg2 = 0 ;
15612   bool result;
15613
15614   arg1 = (Dali::Property::Value *)jarg1;
15615   arg2 = (Dali::AngleAxis *)jarg2;
15616   if (!arg2) {
15617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15618     return 0;
15619   }
15620   {
15621     try {
15622       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15623     } catch (std::out_of_range& e) {
15624       {
15625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15626       };
15627     } catch (std::exception& e) {
15628       {
15629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15630       };
15631     } catch (...) {
15632       {
15633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15634       };
15635     }
15636   }
15637   jresult = result;
15638   return jresult;
15639 }
15640
15641
15642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15643   unsigned int jresult ;
15644   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15645   Dali::Quaternion *arg2 = 0 ;
15646   bool result;
15647
15648   arg1 = (Dali::Property::Value *)jarg1;
15649   arg2 = (Dali::Quaternion *)jarg2;
15650   if (!arg2) {
15651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15652     return 0;
15653   }
15654   {
15655     try {
15656       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15657     } catch (std::out_of_range& e) {
15658       {
15659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15660       };
15661     } catch (std::exception& e) {
15662       {
15663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15664       };
15665     } catch (...) {
15666       {
15667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15668       };
15669     }
15670   }
15671   jresult = result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15677   unsigned int jresult ;
15678   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15679   std::string *arg2 = 0 ;
15680   bool result;
15681
15682   arg1 = (Dali::Property::Value *)jarg1;
15683
15684   //typemap in
15685   std::string temp;
15686   arg2 = &temp;
15687
15688   {
15689     try {
15690       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15691     } catch (std::out_of_range& e) {
15692       {
15693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15694       };
15695     } catch (std::exception& e) {
15696       {
15697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15698       };
15699     } catch (...) {
15700       {
15701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15702       };
15703     }
15704   }
15705   jresult = result;
15706
15707   //Typemap argout in c++ file.
15708   //This will convert c++ string to c# string
15709   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15710
15711   return jresult;
15712 }
15713
15714
15715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15716   unsigned int jresult ;
15717   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15718   Dali::Property::Array *arg2 = 0 ;
15719   bool result;
15720
15721   arg1 = (Dali::Property::Value *)jarg1;
15722   arg2 = (Dali::Property::Array *)jarg2;
15723   if (!arg2) {
15724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15725     return 0;
15726   }
15727   {
15728     try {
15729       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15730     } catch (std::out_of_range& e) {
15731       {
15732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15733       };
15734     } catch (std::exception& e) {
15735       {
15736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15737       };
15738     } catch (...) {
15739       {
15740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15741       };
15742     }
15743   }
15744   jresult = result;
15745   return jresult;
15746 }
15747
15748
15749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15750   unsigned int jresult ;
15751   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15752   Dali::Property::Map *arg2 = 0 ;
15753   bool result;
15754
15755   arg1 = (Dali::Property::Value *)jarg1;
15756   arg2 = (Dali::Property::Map *)jarg2;
15757   if (!arg2) {
15758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15759     return 0;
15760   }
15761   {
15762     try {
15763       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15764     } catch (std::out_of_range& e) {
15765       {
15766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15767       };
15768     } catch (std::exception& e) {
15769       {
15770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15771       };
15772     } catch (...) {
15773       {
15774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15775       };
15776     }
15777   }
15778   jresult = result;
15779   return jresult;
15780 }
15781
15782
15783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15784   void * jresult ;
15785   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15786   Dali::Property::Array *result = 0 ;
15787
15788   arg1 = (Dali::Property::Value *)jarg1;
15789   {
15790     try {
15791       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15792     } catch (std::out_of_range& e) {
15793       {
15794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15795       };
15796     } catch (std::exception& e) {
15797       {
15798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15803       };
15804     }
15805   }
15806   jresult = (void *)result;
15807   return jresult;
15808 }
15809
15810
15811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15812   void * jresult ;
15813   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15814   Dali::Property::Map *result = 0 ;
15815
15816   arg1 = (Dali::Property::Value *)jarg1;
15817   {
15818     try {
15819       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15820     } catch (std::out_of_range& e) {
15821       {
15822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15823       };
15824     } catch (std::exception& e) {
15825       {
15826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15827       };
15828     } catch (...) {
15829       {
15830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15831       };
15832     }
15833   }
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15840   char * jresult ;
15841   Dali::Property::Type arg1 ;
15842   char *result = 0 ;
15843
15844   arg1 = (Dali::Property::Type)jarg1;
15845   {
15846     try {
15847       result = (char *)Dali::PropertyTypes::GetName(arg1);
15848     } catch (std::out_of_range& e) {
15849       {
15850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15851       };
15852     } catch (std::exception& e) {
15853       {
15854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (...) {
15857       {
15858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15859       };
15860     }
15861   }
15862   jresult = SWIG_csharp_string_callback((const char *)result);
15863   return jresult;
15864 }
15865
15866
15867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15868   unsigned int jresult ;
15869   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15870   std::string *arg2 = 0 ;
15871   Dali::Property::Map *arg3 = 0 ;
15872   bool result;
15873
15874   arg1 = (Dali::BaseObject *)jarg1;
15875   if (!jarg2) {
15876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15877     return 0;
15878   }
15879   std::string arg2_str(jarg2);
15880   arg2 = &arg2_str;
15881   arg3 = (Dali::Property::Map *)jarg3;
15882   if (!arg3) {
15883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15884     return 0;
15885   }
15886   {
15887     try {
15888       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15889     } catch (std::out_of_range& e) {
15890       {
15891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15892       };
15893     } catch (std::exception& e) {
15894       {
15895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15900       };
15901     }
15902   }
15903   jresult = result;
15904
15905   //argout typemap for const std::string&
15906
15907   return jresult;
15908 }
15909
15910
15911 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15912   char * jresult ;
15913   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15914   std::string *result = 0 ;
15915
15916   arg1 = (Dali::BaseObject *)jarg1;
15917   {
15918     try {
15919       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15920     } catch (std::out_of_range& e) {
15921       {
15922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (std::exception& e) {
15925       {
15926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934   jresult = SWIG_csharp_string_callback(result->c_str());
15935   return jresult;
15936 }
15937
15938
15939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15940   unsigned int jresult ;
15941   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15942   Dali::TypeInfo *arg2 = 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::BaseObject *)jarg1;
15946   arg2 = (Dali::TypeInfo *)jarg2;
15947   if (!arg2) {
15948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15949     return 0;
15950   }
15951   {
15952     try {
15953       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15954     } catch (std::out_of_range& e) {
15955       {
15956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15957       };
15958     } catch (std::exception& e) {
15959       {
15960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15961       };
15962     } catch (...) {
15963       {
15964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15965       };
15966     }
15967   }
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15974   unsigned int jresult ;
15975   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15976   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15977   std::string *arg3 = 0 ;
15978   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15979   bool result;
15980
15981   arg1 = (Dali::BaseObject *)jarg1;
15982   arg2 = (ConnectionTrackerInterface *)jarg2;
15983   if (!jarg3) {
15984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15985     return 0;
15986   }
15987   std::string arg3_str(jarg3);
15988   arg3 = &arg3_str;
15989   arg4 = (FunctorDelegate *)jarg4;
15990   {
15991     try {
15992       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15993     } catch (std::out_of_range& e) {
15994       {
15995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15996       };
15997     } catch (std::exception& e) {
15998       {
15999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16000       };
16001     } catch (...) {
16002       {
16003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16004       };
16005     }
16006   }
16007   jresult = result;
16008
16009   //argout typemap for const std::string&
16010
16011   return jresult;
16012 }
16013
16014
16015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16016   void * jresult ;
16017   Dali::BaseHandle *arg1 = 0 ;
16018   Dali::BaseObject *result = 0 ;
16019
16020   arg1 = (Dali::BaseHandle *)jarg1;
16021   if (!arg1) {
16022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16023     return 0;
16024   }
16025   {
16026     try {
16027       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16028     } catch (std::out_of_range& e) {
16029       {
16030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16031       };
16032     } catch (std::exception& e) {
16033       {
16034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16035       };
16036     } catch (...) {
16037       {
16038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16039       };
16040     }
16041   }
16042   jresult = (void *)result;
16043   return jresult;
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16048   void * jresult ;
16049   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16050   Dali::BaseHandle *result = 0 ;
16051
16052   arg1 = (Dali::BaseObject *)jarg1;
16053   {
16054     try {
16055       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (...) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16067       };
16068     }
16069   }
16070   jresult = (void *)result;
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16076   void * jresult ;
16077   Dali::BaseHandle *result = 0 ;
16078
16079   {
16080     try {
16081       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16082     } catch (std::out_of_range& e) {
16083       {
16084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16085       };
16086     } catch (std::exception& e) {
16087       {
16088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16089       };
16090     } catch (...) {
16091       {
16092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16093       };
16094     }
16095   }
16096   jresult = (void *)result;
16097   return jresult;
16098 }
16099
16100
16101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16102   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16103
16104   arg1 = (Dali::BaseHandle *)jarg1;
16105   {
16106     try {
16107       delete arg1;
16108     } catch (std::out_of_range& e) {
16109       {
16110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16111       };
16112     } catch (std::exception& e) {
16113       {
16114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16115       };
16116     } catch (...) {
16117       {
16118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16119       };
16120     }
16121   }
16122 }
16123
16124
16125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16126   void * jresult ;
16127   Dali::BaseHandle *arg1 = 0 ;
16128   Dali::BaseHandle *result = 0 ;
16129
16130   arg1 = (Dali::BaseHandle *)jarg1;
16131   if (!arg1) {
16132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16133     return 0;
16134   }
16135   {
16136     try {
16137       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (...) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16149       };
16150     }
16151   }
16152   jresult = (void *)result;
16153   return jresult;
16154 }
16155
16156
16157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16158   void * jresult ;
16159   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16160   Dali::BaseHandle *arg2 = 0 ;
16161   Dali::BaseHandle *result = 0 ;
16162
16163   arg1 = (Dali::BaseHandle *)jarg1;
16164   arg2 = (Dali::BaseHandle *)jarg2;
16165   if (!arg2) {
16166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16167     return 0;
16168   }
16169   {
16170     try {
16171       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16172     } catch (std::out_of_range& e) {
16173       {
16174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16175       };
16176     } catch (std::exception& e) {
16177       {
16178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (...) {
16181       {
16182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16183       };
16184     }
16185   }
16186   jresult = (void *)result;
16187   return jresult;
16188 }
16189
16190
16191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16192   unsigned int jresult ;
16193   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16194   std::string *arg2 = 0 ;
16195   Dali::Property::Map *arg3 = 0 ;
16196   bool result;
16197
16198   arg1 = (Dali::BaseHandle *)jarg1;
16199   if (!jarg2) {
16200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16201     return 0;
16202   }
16203   std::string arg2_str(jarg2);
16204   arg2 = &arg2_str;
16205   arg3 = (Dali::Property::Map *)jarg3;
16206   if (!arg3) {
16207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16208     return 0;
16209   }
16210   {
16211     try {
16212       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16213     } catch (std::out_of_range& e) {
16214       {
16215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16216       };
16217     } catch (std::exception& e) {
16218       {
16219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16220       };
16221     } catch (...) {
16222       {
16223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16224       };
16225     }
16226   }
16227   jresult = result;
16228
16229   //argout typemap for const std::string&
16230
16231   return jresult;
16232 }
16233
16234
16235 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16236   char * jresult ;
16237   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16238   std::string *result = 0 ;
16239
16240   arg1 = (Dali::BaseHandle *)jarg1;
16241   {
16242     try {
16243       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16244     } catch (std::out_of_range& e) {
16245       {
16246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16247       };
16248     } catch (std::exception& e) {
16249       {
16250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16251       };
16252     } catch (...) {
16253       {
16254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16255       };
16256     }
16257   }
16258   jresult = SWIG_csharp_string_callback(result->c_str());
16259   return jresult;
16260 }
16261
16262
16263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16264   unsigned int jresult ;
16265   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16266   Dali::TypeInfo *arg2 = 0 ;
16267   bool result;
16268
16269   arg1 = (Dali::BaseHandle *)jarg1;
16270   arg2 = (Dali::TypeInfo *)jarg2;
16271   if (!arg2) {
16272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16273     return 0;
16274   }
16275   {
16276     try {
16277       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (...) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16289       };
16290     }
16291   }
16292   jresult = result;
16293   return jresult;
16294 }
16295
16296
16297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16298   void * jresult ;
16299   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16300   Dali::BaseObject *result = 0 ;
16301
16302   arg1 = (Dali::BaseHandle *)jarg1;
16303   {
16304     try {
16305       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16306     } catch (std::out_of_range& e) {
16307       {
16308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (std::exception& e) {
16311       {
16312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (...) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16317       };
16318     }
16319   }
16320   jresult = (void *)result;
16321   return jresult;
16322 }
16323
16324
16325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16326   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16327
16328   arg1 = (Dali::BaseHandle *)jarg1;
16329   {
16330     try {
16331       (arg1)->Reset();
16332     } catch (std::out_of_range& e) {
16333       {
16334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16335       };
16336     } catch (std::exception& e) {
16337       {
16338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16339       };
16340     } catch (...) {
16341       {
16342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16343       };
16344     }
16345   }
16346 }
16347
16348
16349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16350   unsigned int jresult ;
16351   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16352   Dali::BaseHandle *arg2 = 0 ;
16353   bool result;
16354
16355   arg1 = (Dali::BaseHandle *)jarg1;
16356   arg2 = (Dali::BaseHandle *)jarg2;
16357   if (!arg2) {
16358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16359     return 0;
16360   }
16361   {
16362     try {
16363       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16364     } catch (std::out_of_range& e) {
16365       {
16366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (std::exception& e) {
16369       {
16370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16371       };
16372     } catch (...) {
16373       {
16374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16375       };
16376     }
16377   }
16378   jresult = result;
16379   return jresult;
16380 }
16381
16382
16383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16384   unsigned int jresult ;
16385   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16386   Dali::BaseHandle *arg2 = 0 ;
16387   bool result;
16388
16389   arg1 = (Dali::BaseHandle *)jarg1;
16390   arg2 = (Dali::BaseHandle *)jarg2;
16391   if (!arg2) {
16392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16393     return 0;
16394   }
16395   {
16396     try {
16397       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16398     } catch (std::out_of_range& e) {
16399       {
16400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (std::exception& e) {
16403       {
16404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412   jresult = result;
16413   return jresult;
16414 }
16415
16416
16417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16418   void * jresult ;
16419   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16420   Dali::RefObject *result = 0 ;
16421
16422   arg1 = (Dali::BaseHandle *)jarg1;
16423   {
16424     try {
16425       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16433       };
16434     } catch (...) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16437       };
16438     }
16439   }
16440   jresult = (void *)result;
16441   return jresult;
16442 }
16443
16444
16445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16446   unsigned int jresult ;
16447   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16448   bool result;
16449
16450   arg1 = (Dali::BaseHandle *)jarg1;
16451   {
16452     try {
16453       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16454     } catch (std::out_of_range& e) {
16455       {
16456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16457       };
16458     } catch (std::exception& e) {
16459       {
16460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16461       };
16462     } catch (...) {
16463       {
16464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16465       };
16466     }
16467   }
16468   jresult = result;
16469   return jresult;
16470 }
16471
16472
16473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16474   unsigned int jresult ;
16475   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16476   Dali::BaseHandle *arg2 = 0 ;
16477   bool result;
16478
16479   arg1 = (Dali::BaseHandle *)jarg1;
16480   arg2 = (Dali::BaseHandle *)jarg2;
16481   if (!arg2) {
16482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16483     return 0;
16484   }
16485   {
16486     try {
16487       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16488     } catch (std::out_of_range& e) {
16489       {
16490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16491       };
16492     } catch (std::exception& e) {
16493       {
16494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16495       };
16496     } catch (...) {
16497       {
16498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16499       };
16500     }
16501   }
16502   jresult = result;
16503   return jresult;
16504 }
16505
16506
16507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16508   unsigned int jresult ;
16509   Dali::BaseHandle *arg1 = 0 ;
16510   Dali::BaseHandle *arg2 = 0 ;
16511   bool result;
16512
16513   arg1 = (Dali::BaseHandle *)jarg1;
16514   if (!arg1) {
16515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16516     return 0;
16517   }
16518   arg2 = (Dali::BaseHandle *)jarg2;
16519   if (!arg2) {
16520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16521     return 0;
16522   }
16523   {
16524     try {
16525       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16526     } catch (std::out_of_range& e) {
16527       {
16528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16529       };
16530     } catch (std::exception& e) {
16531       {
16532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16533       };
16534     } catch (...) {
16535       {
16536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16537       };
16538     }
16539   }
16540   jresult = result;
16541   return jresult;
16542 }
16543
16544
16545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16546   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16547
16548   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16549   {
16550     try {
16551       delete arg1;
16552     } catch (std::out_of_range& e) {
16553       {
16554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16555       };
16556     } catch (std::exception& e) {
16557       {
16558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16559       };
16560     } catch (...) {
16561       {
16562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16563       };
16564     }
16565   }
16566 }
16567
16568
16569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16570   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16571   SlotObserver *arg2 = (SlotObserver *) 0 ;
16572   CallbackBase *arg3 = (CallbackBase *) 0 ;
16573
16574   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16575   arg2 = (SlotObserver *)jarg2;
16576   arg3 = (CallbackBase *)jarg3;
16577   {
16578     try {
16579       (arg1)->SignalConnected(arg2,arg3);
16580     } catch (std::out_of_range& e) {
16581       {
16582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16583       };
16584     } catch (std::exception& e) {
16585       {
16586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16591       };
16592     }
16593   }
16594 }
16595
16596
16597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16598   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16599
16600   arg1 = (Dali::SignalObserver *)jarg1;
16601   {
16602     try {
16603       delete arg1;
16604     } catch (std::out_of_range& e) {
16605       {
16606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16607       };
16608     } catch (std::exception& e) {
16609       {
16610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16611       };
16612     } catch (...) {
16613       {
16614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16615       };
16616     }
16617   }
16618 }
16619
16620
16621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16622   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16623   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16624   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16625
16626   arg1 = (Dali::SignalObserver *)jarg1;
16627   arg2 = (Dali::SlotObserver *)jarg2;
16628   arg3 = (Dali::CallbackBase *)jarg3;
16629   {
16630     try {
16631       (arg1)->SignalDisconnected(arg2,arg3);
16632     } catch (std::out_of_range& e) {
16633       {
16634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16635       };
16636     } catch (std::exception& e) {
16637       {
16638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16639       };
16640     } catch (...) {
16641       {
16642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16643       };
16644     }
16645   }
16646 }
16647
16648
16649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16650   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16651
16652   arg1 = (Dali::SlotObserver *)jarg1;
16653   {
16654     try {
16655       delete arg1;
16656     } catch (std::out_of_range& e) {
16657       {
16658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16659       };
16660     } catch (std::exception& e) {
16661       {
16662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16667       };
16668     }
16669   }
16670 }
16671
16672
16673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16674   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16675   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16676
16677   arg1 = (Dali::SlotObserver *)jarg1;
16678   arg2 = (Dali::CallbackBase *)jarg2;
16679   {
16680     try {
16681       (arg1)->SlotDisconnected(arg2);
16682     } catch (std::out_of_range& e) {
16683       {
16684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16685       };
16686     } catch (std::exception& e) {
16687       {
16688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16689       };
16690     } catch (...) {
16691       {
16692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16693       };
16694     }
16695   }
16696 }
16697
16698
16699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16700   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16701
16702   arg1 = (Dali::ConnectionTracker *)jarg1;
16703   {
16704     try {
16705       delete arg1;
16706     } catch (std::out_of_range& e) {
16707       {
16708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16709       };
16710     } catch (std::exception& e) {
16711       {
16712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16713       };
16714     } catch (...) {
16715       {
16716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16717       };
16718     }
16719   }
16720 }
16721
16722
16723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16724   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16725
16726   arg1 = (Dali::ConnectionTracker *)jarg1;
16727   {
16728     try {
16729       (arg1)->DisconnectAll();
16730     } catch (std::out_of_range& e) {
16731       {
16732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16733       };
16734     } catch (std::exception& e) {
16735       {
16736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16737       };
16738     } catch (...) {
16739       {
16740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16741       };
16742     }
16743   }
16744 }
16745
16746
16747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16748   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16749   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16750   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16751
16752   arg1 = (Dali::ConnectionTracker *)jarg1;
16753   arg2 = (Dali::SlotObserver *)jarg2;
16754   arg3 = (Dali::CallbackBase *)jarg3;
16755   {
16756     try {
16757       (arg1)->SignalConnected(arg2,arg3);
16758     } catch (std::out_of_range& e) {
16759       {
16760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16761       };
16762     } catch (std::exception& e) {
16763       {
16764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16765       };
16766     } catch (...) {
16767       {
16768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16769       };
16770     }
16771   }
16772 }
16773
16774
16775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16776   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16777   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16778   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16779
16780   arg1 = (Dali::ConnectionTracker *)jarg1;
16781   arg2 = (Dali::SlotObserver *)jarg2;
16782   arg3 = (Dali::CallbackBase *)jarg3;
16783   {
16784     try {
16785       (arg1)->SignalDisconnected(arg2,arg3);
16786     } catch (std::out_of_range& e) {
16787       {
16788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16789       };
16790     } catch (std::exception& e) {
16791       {
16792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16793       };
16794     } catch (...) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16797       };
16798     }
16799   }
16800 }
16801
16802
16803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16804   unsigned long jresult ;
16805   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16806   std::size_t result;
16807
16808   arg1 = (Dali::ConnectionTracker *)jarg1;
16809   {
16810     try {
16811       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16812     } catch (std::out_of_range& e) {
16813       {
16814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16815       };
16816     } catch (std::exception& e) {
16817       {
16818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16823       };
16824     }
16825   }
16826   jresult = (unsigned long)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16832   void * jresult ;
16833   Dali::ObjectRegistry *result = 0 ;
16834
16835   {
16836     try {
16837       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16838     } catch (std::out_of_range& e) {
16839       {
16840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16841       };
16842     } catch (std::exception& e) {
16843       {
16844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16845       };
16846     } catch (...) {
16847       {
16848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16849       };
16850     }
16851   }
16852   jresult = (void *)result;
16853   return jresult;
16854 }
16855
16856
16857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16858   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16859
16860   arg1 = (Dali::ObjectRegistry *)jarg1;
16861   {
16862     try {
16863       delete arg1;
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16871       };
16872     } catch (...) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16875       };
16876     }
16877   }
16878 }
16879
16880
16881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16882   void * jresult ;
16883   Dali::ObjectRegistry *arg1 = 0 ;
16884   Dali::ObjectRegistry *result = 0 ;
16885
16886   arg1 = (Dali::ObjectRegistry *)jarg1;
16887   if (!arg1) {
16888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16889     return 0;
16890   }
16891   {
16892     try {
16893       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16894     } catch (std::out_of_range& e) {
16895       {
16896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16897       };
16898     } catch (std::exception& e) {
16899       {
16900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16901       };
16902     } catch (...) {
16903       {
16904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16905       };
16906     }
16907   }
16908   jresult = (void *)result;
16909   return jresult;
16910 }
16911
16912
16913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16914   void * jresult ;
16915   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16916   Dali::ObjectRegistry *arg2 = 0 ;
16917   Dali::ObjectRegistry *result = 0 ;
16918
16919   arg1 = (Dali::ObjectRegistry *)jarg1;
16920   arg2 = (Dali::ObjectRegistry *)jarg2;
16921   if (!arg2) {
16922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16923     return 0;
16924   }
16925   {
16926     try {
16927       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16928     } catch (std::out_of_range& e) {
16929       {
16930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16931       };
16932     } catch (std::exception& e) {
16933       {
16934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16935       };
16936     } catch (...) {
16937       {
16938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16939       };
16940     }
16941   }
16942   jresult = (void *)result;
16943   return jresult;
16944 }
16945
16946
16947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16948   void * jresult ;
16949   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16950   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16951
16952   arg1 = (Dali::ObjectRegistry *)jarg1;
16953   {
16954     try {
16955       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16956     } catch (std::out_of_range& e) {
16957       {
16958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (std::exception& e) {
16961       {
16962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16963       };
16964     } catch (...) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16967       };
16968     }
16969   }
16970   jresult = (void *)result;
16971   return jresult;
16972 }
16973
16974
16975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16976   void * jresult ;
16977   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16978   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16979
16980   arg1 = (Dali::ObjectRegistry *)jarg1;
16981   {
16982     try {
16983       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16984     } catch (std::out_of_range& e) {
16985       {
16986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16987       };
16988     } catch (std::exception& e) {
16989       {
16990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16991       };
16992     } catch (...) {
16993       {
16994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16995       };
16996     }
16997   }
16998   jresult = (void *)result;
16999   return jresult;
17000 }
17001
17002
17003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17004   void * jresult ;
17005   Dali::PropertyCondition *result = 0 ;
17006
17007   {
17008     try {
17009       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (...) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17021       };
17022     }
17023   }
17024   jresult = (void *)result;
17025   return jresult;
17026 }
17027
17028
17029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17030   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17031
17032   arg1 = (Dali::PropertyCondition *)jarg1;
17033   {
17034     try {
17035       delete arg1;
17036     } catch (std::out_of_range& e) {
17037       {
17038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17039       };
17040     } catch (std::exception& e) {
17041       {
17042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17043       };
17044     } catch (...) {
17045       {
17046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17047       };
17048     }
17049   }
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17054   void * jresult ;
17055   Dali::PropertyCondition *arg1 = 0 ;
17056   Dali::PropertyCondition *result = 0 ;
17057
17058   arg1 = (Dali::PropertyCondition *)jarg1;
17059   if (!arg1) {
17060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17061     return 0;
17062   }
17063   {
17064     try {
17065       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (...) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17077       };
17078     }
17079   }
17080   jresult = (void *)result;
17081   return jresult;
17082 }
17083
17084
17085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17086   void * jresult ;
17087   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17088   Dali::PropertyCondition *arg2 = 0 ;
17089   Dali::PropertyCondition *result = 0 ;
17090
17091   arg1 = (Dali::PropertyCondition *)jarg1;
17092   arg2 = (Dali::PropertyCondition *)jarg2;
17093   if (!arg2) {
17094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17095     return 0;
17096   }
17097   {
17098     try {
17099       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17100     } catch (std::out_of_range& e) {
17101       {
17102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17103       };
17104     } catch (std::exception& e) {
17105       {
17106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (...) {
17109       {
17110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17111       };
17112     }
17113   }
17114   jresult = (void *)result;
17115   return jresult;
17116 }
17117
17118
17119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17120   unsigned long jresult ;
17121   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17122   std::size_t result;
17123
17124   arg1 = (Dali::PropertyCondition *)jarg1;
17125   {
17126     try {
17127       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17128     } catch (std::out_of_range& e) {
17129       {
17130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17131       };
17132     } catch (std::exception& e) {
17133       {
17134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17135       };
17136     } catch (...) {
17137       {
17138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17139       };
17140     }
17141   }
17142   jresult = (unsigned long)result;
17143   return jresult;
17144 }
17145
17146
17147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17148   float jresult ;
17149   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17150   std::size_t arg2 ;
17151   float result;
17152
17153   arg1 = (Dali::PropertyCondition *)jarg1;
17154   arg2 = (std::size_t)jarg2;
17155   {
17156     try {
17157       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17158     } catch (std::out_of_range& e) {
17159       {
17160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17161       };
17162     } catch (std::exception& e) {
17163       {
17164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (...) {
17167       {
17168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17169       };
17170     }
17171   }
17172   jresult = result;
17173   return jresult;
17174 }
17175
17176
17177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17178   void * jresult ;
17179   float arg1 ;
17180   Dali::PropertyCondition result;
17181
17182   arg1 = (float)jarg1;
17183   {
17184     try {
17185       result = Dali::LessThanCondition(arg1);
17186     } catch (std::out_of_range& e) {
17187       {
17188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (std::exception& e) {
17191       {
17192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17206   void * jresult ;
17207   float arg1 ;
17208   Dali::PropertyCondition result;
17209
17210   arg1 = (float)jarg1;
17211   {
17212     try {
17213       result = Dali::GreaterThanCondition(arg1);
17214     } catch (std::out_of_range& e) {
17215       {
17216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17217       };
17218     } catch (std::exception& e) {
17219       {
17220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (...) {
17223       {
17224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17225       };
17226     }
17227   }
17228   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17229   return jresult;
17230 }
17231
17232
17233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17234   void * jresult ;
17235   float arg1 ;
17236   float arg2 ;
17237   Dali::PropertyCondition result;
17238
17239   arg1 = (float)jarg1;
17240   arg2 = (float)jarg2;
17241   {
17242     try {
17243       result = Dali::InsideCondition(arg1,arg2);
17244     } catch (std::out_of_range& e) {
17245       {
17246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17247       };
17248     } catch (std::exception& e) {
17249       {
17250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17251       };
17252     } catch (...) {
17253       {
17254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17255       };
17256     }
17257   }
17258   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17259   return jresult;
17260 }
17261
17262
17263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17264   void * jresult ;
17265   float arg1 ;
17266   float arg2 ;
17267   Dali::PropertyCondition result;
17268
17269   arg1 = (float)jarg1;
17270   arg2 = (float)jarg2;
17271   {
17272     try {
17273       result = Dali::OutsideCondition(arg1,arg2);
17274     } catch (std::out_of_range& e) {
17275       {
17276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17277       };
17278     } catch (std::exception& e) {
17279       {
17280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17281       };
17282     } catch (...) {
17283       {
17284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17285       };
17286     }
17287   }
17288   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17289   return jresult;
17290 }
17291
17292
17293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17294   void * jresult ;
17295   float arg1 ;
17296   float arg2 ;
17297   Dali::PropertyCondition result;
17298
17299   arg1 = (float)jarg1;
17300   arg2 = (float)jarg2;
17301   {
17302     try {
17303       result = Dali::StepCondition(arg1,arg2);
17304     } catch (std::out_of_range& e) {
17305       {
17306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17307       };
17308     } catch (std::exception& e) {
17309       {
17310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17311       };
17312     } catch (...) {
17313       {
17314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17315       };
17316     }
17317   }
17318   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17324   void * jresult ;
17325   float arg1 ;
17326   Dali::PropertyCondition result;
17327
17328   arg1 = (float)jarg1;
17329   {
17330     try {
17331       result = Dali::StepCondition(arg1);
17332     } catch (std::out_of_range& e) {
17333       {
17334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17335       };
17336     } catch (std::exception& e) {
17337       {
17338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17339       };
17340     } catch (...) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17343       };
17344     }
17345   }
17346   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17347   return jresult;
17348 }
17349
17350
17351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17352   void * jresult ;
17353   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17354   Dali::PropertyCondition result;
17355
17356   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17357   if (!arg1) {
17358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17359     return 0;
17360   }
17361   {
17362     try {
17363       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (...) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17375       };
17376     }
17377   }
17378   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17384   void * jresult ;
17385   Dali::PropertyNotification *result = 0 ;
17386
17387   {
17388     try {
17389       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17390     } catch (std::out_of_range& e) {
17391       {
17392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17393       };
17394     } catch (std::exception& e) {
17395       {
17396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17397       };
17398     } catch (...) {
17399       {
17400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17401       };
17402     }
17403   }
17404   jresult = (void *)result;
17405   return jresult;
17406 }
17407
17408
17409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17410   void * jresult ;
17411   Dali::BaseHandle arg1 ;
17412   Dali::BaseHandle *argp1 ;
17413   Dali::PropertyNotification result;
17414
17415   argp1 = (Dali::BaseHandle *)jarg1;
17416   if (!argp1) {
17417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17418     return 0;
17419   }
17420   arg1 = *argp1;
17421   {
17422     try {
17423       result = Dali::PropertyNotification::DownCast(arg1);
17424     } catch (std::out_of_range& e) {
17425       {
17426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (std::exception& e) {
17429       {
17430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17444   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17445
17446   arg1 = (Dali::PropertyNotification *)jarg1;
17447   {
17448     try {
17449       delete arg1;
17450     } catch (std::out_of_range& e) {
17451       {
17452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17453       };
17454     } catch (std::exception& e) {
17455       {
17456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17457       };
17458     } catch (...) {
17459       {
17460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17461       };
17462     }
17463   }
17464 }
17465
17466
17467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17468   void * jresult ;
17469   Dali::PropertyNotification *arg1 = 0 ;
17470   Dali::PropertyNotification *result = 0 ;
17471
17472   arg1 = (Dali::PropertyNotification *)jarg1;
17473   if (!arg1) {
17474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17475     return 0;
17476   }
17477   {
17478     try {
17479       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17480     } catch (std::out_of_range& e) {
17481       {
17482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17483       };
17484     } catch (std::exception& e) {
17485       {
17486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (...) {
17489       {
17490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17491       };
17492     }
17493   }
17494   jresult = (void *)result;
17495   return jresult;
17496 }
17497
17498
17499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17500   void * jresult ;
17501   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17502   Dali::PropertyNotification *arg2 = 0 ;
17503   Dali::PropertyNotification *result = 0 ;
17504
17505   arg1 = (Dali::PropertyNotification *)jarg1;
17506   arg2 = (Dali::PropertyNotification *)jarg2;
17507   if (!arg2) {
17508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17509     return 0;
17510   }
17511   {
17512     try {
17513       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17514     } catch (std::out_of_range& e) {
17515       {
17516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17517       };
17518     } catch (std::exception& e) {
17519       {
17520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17521       };
17522     } catch (...) {
17523       {
17524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17525       };
17526     }
17527   }
17528   jresult = (void *)result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17534   void * jresult ;
17535   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17536   Dali::PropertyCondition result;
17537
17538   arg1 = (Dali::PropertyNotification *)jarg1;
17539   {
17540     try {
17541       result = (arg1)->GetCondition();
17542     } catch (std::out_of_range& e) {
17543       {
17544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17545       };
17546     } catch (std::exception& e) {
17547       {
17548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17549       };
17550     } catch (...) {
17551       {
17552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17553       };
17554     }
17555   }
17556   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17557   return jresult;
17558 }
17559
17560
17561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17562   void * jresult ;
17563   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17564   Dali::Handle result;
17565
17566   arg1 = (Dali::PropertyNotification *)jarg1;
17567   {
17568     try {
17569       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17570     } catch (std::out_of_range& e) {
17571       {
17572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (std::exception& e) {
17575       {
17576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17577       };
17578     } catch (...) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17581       };
17582     }
17583   }
17584   jresult = new Dali::Handle((const Dali::Handle &)result);
17585   return jresult;
17586 }
17587
17588
17589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17590   int jresult ;
17591   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17592   Dali::Property::Index result;
17593
17594   arg1 = (Dali::PropertyNotification *)jarg1;
17595   {
17596     try {
17597       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17598     } catch (std::out_of_range& e) {
17599       {
17600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17601       };
17602     } catch (std::exception& e) {
17603       {
17604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17605       };
17606     } catch (...) {
17607       {
17608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17609       };
17610     }
17611   }
17612   jresult = result;
17613   return jresult;
17614 }
17615
17616
17617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17618   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17619   Dali::PropertyNotification::NotifyMode arg2 ;
17620
17621   arg1 = (Dali::PropertyNotification *)jarg1;
17622   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17623   {
17624     try {
17625       (arg1)->SetNotifyMode(arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17637       };
17638     }
17639   }
17640 }
17641
17642
17643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17644   int jresult ;
17645   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17646   Dali::PropertyNotification::NotifyMode result;
17647
17648   arg1 = (Dali::PropertyNotification *)jarg1;
17649   {
17650     try {
17651       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17652     } catch (std::out_of_range& e) {
17653       {
17654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17655       };
17656     } catch (std::exception& e) {
17657       {
17658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17659       };
17660     } catch (...) {
17661       {
17662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17663       };
17664     }
17665   }
17666   jresult = (int)result;
17667   return jresult;
17668 }
17669
17670
17671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17672   unsigned int jresult ;
17673   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17674   bool result;
17675
17676   arg1 = (Dali::PropertyNotification *)jarg1;
17677   {
17678     try {
17679       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17680     } catch (std::out_of_range& e) {
17681       {
17682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17683       };
17684     } catch (std::exception& e) {
17685       {
17686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17687       };
17688     } catch (...) {
17689       {
17690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17691       };
17692     }
17693   }
17694   jresult = result;
17695   return jresult;
17696 }
17697
17698
17699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17700   void * jresult ;
17701   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17702   Dali::PropertyNotifySignalType *result = 0 ;
17703
17704   arg1 = (Dali::PropertyNotification *)jarg1;
17705   {
17706     try {
17707       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17708     } catch (std::out_of_range& e) {
17709       {
17710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (std::exception& e) {
17713       {
17714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722   jresult = (void *)result;
17723   return jresult;
17724 }
17725
17726
17727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17728   void * jresult ;
17729   Dali::Handle *result = 0 ;
17730
17731   {
17732     try {
17733       result = (Dali::Handle *)new Dali::Handle();
17734     } catch (std::out_of_range& e) {
17735       {
17736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17737       };
17738     } catch (std::exception& e) {
17739       {
17740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17741       };
17742     } catch (...) {
17743       {
17744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17745       };
17746     }
17747   }
17748   jresult = (void *)result;
17749   return jresult;
17750 }
17751
17752
17753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17754   void * jresult ;
17755   Dali::Handle result;
17756
17757   {
17758     try {
17759       result = Dali::Handle::New();
17760     } catch (std::out_of_range& e) {
17761       {
17762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17763       };
17764     } catch (std::exception& e) {
17765       {
17766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (...) {
17769       {
17770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17771       };
17772     }
17773   }
17774   jresult = new Dali::Handle((const Dali::Handle &)result);
17775   return jresult;
17776 }
17777
17778
17779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17780   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17781
17782   arg1 = (Dali::Handle *)jarg1;
17783   {
17784     try {
17785       delete arg1;
17786     } catch (std::out_of_range& e) {
17787       {
17788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17789       };
17790     } catch (std::exception& e) {
17791       {
17792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17797       };
17798     }
17799   }
17800 }
17801
17802
17803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17804   void * jresult ;
17805   Dali::Handle *arg1 = 0 ;
17806   Dali::Handle *result = 0 ;
17807
17808   arg1 = (Dali::Handle *)jarg1;
17809   if (!arg1) {
17810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17811     return 0;
17812   }
17813   {
17814     try {
17815       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17816     } catch (std::out_of_range& e) {
17817       {
17818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17819       };
17820     } catch (std::exception& e) {
17821       {
17822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17823       };
17824     } catch (...) {
17825       {
17826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17827       };
17828     }
17829   }
17830   jresult = (void *)result;
17831   return jresult;
17832 }
17833
17834
17835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17836   void * jresult ;
17837   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17838   Dali::Handle *arg2 = 0 ;
17839   Dali::Handle *result = 0 ;
17840
17841   arg1 = (Dali::Handle *)jarg1;
17842   arg2 = (Dali::Handle *)jarg2;
17843   if (!arg2) {
17844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17845     return 0;
17846   }
17847   {
17848     try {
17849       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17850     } catch (std::out_of_range& e) {
17851       {
17852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17853       };
17854     } catch (std::exception& e) {
17855       {
17856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17857       };
17858     } catch (...) {
17859       {
17860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17861       };
17862     }
17863   }
17864   jresult = (void *)result;
17865   return jresult;
17866 }
17867
17868
17869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17870   void * jresult ;
17871   Dali::BaseHandle arg1 ;
17872   Dali::BaseHandle *argp1 ;
17873   Dali::Handle result;
17874
17875   argp1 = (Dali::BaseHandle *)jarg1;
17876   if (!argp1) {
17877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17878     return 0;
17879   }
17880   arg1 = *argp1;
17881   {
17882     try {
17883       result = Dali::Handle::DownCast(arg1);
17884     } catch (std::out_of_range& e) {
17885       {
17886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17887       };
17888     } catch (std::exception& e) {
17889       {
17890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17891       };
17892     } catch (...) {
17893       {
17894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17895       };
17896     }
17897   }
17898   jresult = new Dali::Handle((const Dali::Handle &)result);
17899   return jresult;
17900 }
17901
17902
17903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17904   unsigned int jresult ;
17905   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17906   Dali::Handle::Capability arg2 ;
17907   bool result;
17908
17909   arg1 = (Dali::Handle *)jarg1;
17910   arg2 = (Dali::Handle::Capability)jarg2;
17911   {
17912     try {
17913       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17914     } catch (std::out_of_range& e) {
17915       {
17916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17917       };
17918     } catch (std::exception& e) {
17919       {
17920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17921       };
17922     } catch (...) {
17923       {
17924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17925       };
17926     }
17927   }
17928   jresult = result;
17929   return jresult;
17930 }
17931
17932
17933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17934   unsigned int jresult ;
17935   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17936   unsigned int result;
17937
17938   arg1 = (Dali::Handle *)jarg1;
17939   {
17940     try {
17941       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17942     } catch (std::out_of_range& e) {
17943       {
17944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17945       };
17946     } catch (std::exception& e) {
17947       {
17948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17949       };
17950     } catch (...) {
17951       {
17952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17953       };
17954     }
17955   }
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17962   char * jresult ;
17963   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17964   Dali::Property::Index arg2 ;
17965   std::string result;
17966
17967   arg1 = (Dali::Handle *)jarg1;
17968   arg2 = (Dali::Property::Index)jarg2;
17969   {
17970     try {
17971       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17972     } catch (std::out_of_range& e) {
17973       {
17974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17975       };
17976     } catch (std::exception& e) {
17977       {
17978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17979       };
17980     } catch (...) {
17981       {
17982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17983       };
17984     }
17985   }
17986   jresult = SWIG_csharp_string_callback((&result)->c_str());
17987   return jresult;
17988 }
17989
17990
17991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17992   int jresult ;
17993   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17994   std::string *arg2 = 0 ;
17995   Dali::Property::Index result;
17996
17997   arg1 = (Dali::Handle *)jarg1;
17998   if (!jarg2) {
17999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18000     return 0;
18001   }
18002   std::string arg2_str(jarg2);
18003   arg2 = &arg2_str;
18004   {
18005     try {
18006       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18007     } catch (std::out_of_range& e) {
18008       {
18009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18010       };
18011     } catch (std::exception& e) {
18012       {
18013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18014       };
18015     } catch (...) {
18016       {
18017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18018       };
18019     }
18020   }
18021   jresult = result;
18022
18023   //argout typemap for const std::string&
18024
18025   return jresult;
18026 }
18027
18028
18029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18030   unsigned int jresult ;
18031   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18032   Dali::Property::Index arg2 ;
18033   bool result;
18034
18035   arg1 = (Dali::Handle *)jarg1;
18036   arg2 = (Dali::Property::Index)jarg2;
18037   {
18038     try {
18039       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18040     } catch (std::out_of_range& e) {
18041       {
18042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18043       };
18044     } catch (std::exception& e) {
18045       {
18046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18047       };
18048     } catch (...) {
18049       {
18050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18051       };
18052     }
18053   }
18054   jresult = result;
18055   return jresult;
18056 }
18057
18058
18059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18060   unsigned int jresult ;
18061   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18062   Dali::Property::Index arg2 ;
18063   bool result;
18064
18065   arg1 = (Dali::Handle *)jarg1;
18066   arg2 = (Dali::Property::Index)jarg2;
18067   {
18068     try {
18069       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18070     } catch (std::out_of_range& e) {
18071       {
18072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18073       };
18074     } catch (std::exception& e) {
18075       {
18076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18077       };
18078     } catch (...) {
18079       {
18080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18081       };
18082     }
18083   }
18084   jresult = result;
18085   return jresult;
18086 }
18087
18088
18089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18090   unsigned int jresult ;
18091   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18092   Dali::Property::Index arg2 ;
18093   bool result;
18094
18095   arg1 = (Dali::Handle *)jarg1;
18096   arg2 = (Dali::Property::Index)jarg2;
18097   {
18098     try {
18099       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18100     } catch (std::out_of_range& e) {
18101       {
18102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18103       };
18104     } catch (std::exception& e) {
18105       {
18106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18107       };
18108     } catch (...) {
18109       {
18110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18111       };
18112     }
18113   }
18114   jresult = result;
18115   return jresult;
18116 }
18117
18118
18119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18120   int jresult ;
18121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18122   Dali::Property::Index arg2 ;
18123   Dali::Property::Type result;
18124
18125   arg1 = (Dali::Handle *)jarg1;
18126   arg2 = (Dali::Property::Index)jarg2;
18127   {
18128     try {
18129       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18130     } catch (std::out_of_range& e) {
18131       {
18132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18133       };
18134     } catch (std::exception& e) {
18135       {
18136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18137       };
18138     } catch (...) {
18139       {
18140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18141       };
18142     }
18143   }
18144   jresult = (int)result;
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18151   Dali::Property::Index arg2 ;
18152   Dali::Property::Value *arg3 = 0 ;
18153
18154   arg1 = (Dali::Handle *)jarg1;
18155   arg2 = (Dali::Property::Index)jarg2;
18156   arg3 = (Dali::Property::Value *)jarg3;
18157   if (!arg3) {
18158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18159     return ;
18160   }
18161   {
18162     try {
18163       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18164     } catch (std::out_of_range& e) {
18165       {
18166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18167       };
18168     } catch (std::exception& e) {
18169       {
18170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18175       };
18176     }
18177   }
18178 }
18179
18180
18181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18182   int jresult ;
18183   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18184   std::string *arg2 = 0 ;
18185   Dali::Property::Value *arg3 = 0 ;
18186   Dali::Property::Index result;
18187
18188   arg1 = (Dali::Handle *)jarg1;
18189   if (!jarg2) {
18190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18191     return 0;
18192   }
18193   std::string arg2_str(jarg2);
18194   arg2 = &arg2_str;
18195   arg3 = (Dali::Property::Value *)jarg3;
18196   if (!arg3) {
18197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18198     return 0;
18199   }
18200   {
18201     try {
18202       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18203     } catch (std::out_of_range& e) {
18204       {
18205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18206       };
18207     } catch (std::exception& e) {
18208       {
18209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18210       };
18211     } catch (...) {
18212       {
18213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18214       };
18215     }
18216   }
18217   jresult = result;
18218
18219   //argout typemap for const std::string&
18220
18221   return jresult;
18222 }
18223
18224
18225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18226   int jresult ;
18227   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18228   std::string *arg2 = 0 ;
18229   Dali::Property::Value *arg3 = 0 ;
18230   Dali::Property::AccessMode arg4 ;
18231   Dali::Property::Index result;
18232
18233   arg1 = (Dali::Handle *)jarg1;
18234   if (!jarg2) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18236     return 0;
18237   }
18238   std::string arg2_str(jarg2);
18239   arg2 = &arg2_str;
18240   arg3 = (Dali::Property::Value *)jarg3;
18241   if (!arg3) {
18242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18243     return 0;
18244   }
18245   arg4 = (Dali::Property::AccessMode)jarg4;
18246   {
18247     try {
18248       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18249     } catch (std::out_of_range& e) {
18250       {
18251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18252       };
18253     } catch (std::exception& e) {
18254       {
18255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18256       };
18257     } catch (...) {
18258       {
18259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18260       };
18261     }
18262   }
18263   jresult = result;
18264
18265   //argout typemap for const std::string&
18266
18267   return jresult;
18268 }
18269
18270
18271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18272   void * jresult ;
18273   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18274   Dali::Property::Index arg2 ;
18275   Dali::Property::Value result;
18276
18277   arg1 = (Dali::Handle *)jarg1;
18278   arg2 = (Dali::Property::Index)jarg2;
18279   {
18280     try {
18281       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18282     } catch (std::out_of_range& e) {
18283       {
18284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18285       };
18286     } catch (std::exception& e) {
18287       {
18288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18289       };
18290     } catch (...) {
18291       {
18292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18293       };
18294     }
18295   }
18296   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18302   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18303   Dali::Property::IndexContainer *arg2 = 0 ;
18304
18305   arg1 = (Dali::Handle *)jarg1;
18306   arg2 = (Dali::Property::IndexContainer *)jarg2;
18307   if (!arg2) {
18308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18309     return ;
18310   }
18311   {
18312     try {
18313       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18314     } catch (std::out_of_range& e) {
18315       {
18316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18317       };
18318     } catch (std::exception& e) {
18319       {
18320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18321       };
18322     } catch (...) {
18323       {
18324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18325       };
18326     }
18327   }
18328 }
18329
18330
18331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18332   void * jresult ;
18333   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18334   Dali::Property::Index arg2 ;
18335   Dali::PropertyCondition *arg3 = 0 ;
18336   Dali::PropertyNotification result;
18337
18338   arg1 = (Dali::Handle *)jarg1;
18339   arg2 = (Dali::Property::Index)jarg2;
18340   arg3 = (Dali::PropertyCondition *)jarg3;
18341   if (!arg3) {
18342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18343     return 0;
18344   }
18345   {
18346     try {
18347       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18348     } catch (std::out_of_range& e) {
18349       {
18350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18351       };
18352     } catch (std::exception& e) {
18353       {
18354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18355       };
18356     } catch (...) {
18357       {
18358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18359       };
18360     }
18361   }
18362   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18363   return jresult;
18364 }
18365
18366
18367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18368   void * jresult ;
18369   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18370   Dali::Property::Index arg2 ;
18371   int arg3 ;
18372   Dali::PropertyCondition *arg4 = 0 ;
18373   Dali::PropertyNotification result;
18374
18375   arg1 = (Dali::Handle *)jarg1;
18376   arg2 = (Dali::Property::Index)jarg2;
18377   arg3 = (int)jarg3;
18378   arg4 = (Dali::PropertyCondition *)jarg4;
18379   if (!arg4) {
18380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18381     return 0;
18382   }
18383   {
18384     try {
18385       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18386     } catch (std::out_of_range& e) {
18387       {
18388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18389       };
18390     } catch (std::exception& e) {
18391       {
18392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18393       };
18394     } catch (...) {
18395       {
18396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18397       };
18398     }
18399   }
18400   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18401   return jresult;
18402 }
18403
18404
18405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18406   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18407   Dali::PropertyNotification arg2 ;
18408   Dali::PropertyNotification *argp2 ;
18409
18410   arg1 = (Dali::Handle *)jarg1;
18411   argp2 = (Dali::PropertyNotification *)jarg2;
18412   if (!argp2) {
18413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18414     return ;
18415   }
18416   arg2 = *argp2;
18417   {
18418     try {
18419       (arg1)->RemovePropertyNotification(arg2);
18420     } catch (std::out_of_range& e) {
18421       {
18422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18423       };
18424     } catch (std::exception& e) {
18425       {
18426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18427       };
18428     } catch (...) {
18429       {
18430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18431       };
18432     }
18433   }
18434 }
18435
18436
18437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18438   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18439
18440   arg1 = (Dali::Handle *)jarg1;
18441   {
18442     try {
18443       (arg1)->RemovePropertyNotifications();
18444     } catch (std::out_of_range& e) {
18445       {
18446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18447       };
18448     } catch (std::exception& e) {
18449       {
18450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18451       };
18452     } catch (...) {
18453       {
18454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18455       };
18456     }
18457   }
18458 }
18459
18460
18461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18462   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18463
18464   arg1 = (Dali::Handle *)jarg1;
18465   {
18466     try {
18467       (arg1)->RemoveConstraints();
18468     } catch (std::out_of_range& e) {
18469       {
18470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18471       };
18472     } catch (std::exception& e) {
18473       {
18474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18479       };
18480     }
18481   }
18482 }
18483
18484
18485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18486   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18487   unsigned int arg2 ;
18488
18489   arg1 = (Dali::Handle *)jarg1;
18490   arg2 = (unsigned int)jarg2;
18491   {
18492     try {
18493       (arg1)->RemoveConstraints(arg2);
18494     } catch (std::out_of_range& e) {
18495       {
18496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18497       };
18498     } catch (std::exception& e) {
18499       {
18500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18501       };
18502     } catch (...) {
18503       {
18504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18505       };
18506     }
18507   }
18508 }
18509
18510
18511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18512   int jresult ;
18513   Dali::Property::Index result;
18514
18515   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18516   jresult = result;
18517   return jresult;
18518 }
18519
18520
18521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18522   void * jresult ;
18523   Dali::Handle result;
18524
18525   {
18526     try {
18527       result = Dali::WeightObject::New();
18528     } catch (std::out_of_range& e) {
18529       {
18530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18531       };
18532     } catch (std::exception& e) {
18533       {
18534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (...) {
18537       {
18538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18539       };
18540     }
18541   }
18542   jresult = new Dali::Handle((const Dali::Handle &)result);
18543   return jresult;
18544 }
18545
18546
18547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18548   void * jresult ;
18549   Dali::TypeInfo *result = 0 ;
18550
18551   {
18552     try {
18553       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18554     } catch (std::out_of_range& e) {
18555       {
18556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18557       };
18558     } catch (std::exception& e) {
18559       {
18560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18561       };
18562     } catch (...) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18565       };
18566     }
18567   }
18568   jresult = (void *)result;
18569   return jresult;
18570 }
18571
18572
18573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18574   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18575
18576   arg1 = (Dali::TypeInfo *)jarg1;
18577   {
18578     try {
18579       delete arg1;
18580     } catch (std::out_of_range& e) {
18581       {
18582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18583       };
18584     } catch (std::exception& e) {
18585       {
18586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18587       };
18588     } catch (...) {
18589       {
18590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18591       };
18592     }
18593   }
18594 }
18595
18596
18597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18598   void * jresult ;
18599   Dali::TypeInfo *arg1 = 0 ;
18600   Dali::TypeInfo *result = 0 ;
18601
18602   arg1 = (Dali::TypeInfo *)jarg1;
18603   if (!arg1) {
18604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18605     return 0;
18606   }
18607   {
18608     try {
18609       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18610     } catch (std::out_of_range& e) {
18611       {
18612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (std::exception& e) {
18615       {
18616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18617       };
18618     } catch (...) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18621       };
18622     }
18623   }
18624   jresult = (void *)result;
18625   return jresult;
18626 }
18627
18628
18629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18630   void * jresult ;
18631   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18632   Dali::TypeInfo *arg2 = 0 ;
18633   Dali::TypeInfo *result = 0 ;
18634
18635   arg1 = (Dali::TypeInfo *)jarg1;
18636   arg2 = (Dali::TypeInfo *)jarg2;
18637   if (!arg2) {
18638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18639     return 0;
18640   }
18641   {
18642     try {
18643       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18644     } catch (std::out_of_range& e) {
18645       {
18646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18647       };
18648     } catch (std::exception& e) {
18649       {
18650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18651       };
18652     } catch (...) {
18653       {
18654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18655       };
18656     }
18657   }
18658   jresult = (void *)result;
18659   return jresult;
18660 }
18661
18662
18663 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18664   char * jresult ;
18665   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18666   std::string *result = 0 ;
18667
18668   arg1 = (Dali::TypeInfo *)jarg1;
18669   {
18670     try {
18671       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (...) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18683       };
18684     }
18685   }
18686   jresult = SWIG_csharp_string_callback(result->c_str());
18687   return jresult;
18688 }
18689
18690
18691 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18692   char * jresult ;
18693   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18694   std::string *result = 0 ;
18695
18696   arg1 = (Dali::TypeInfo *)jarg1;
18697   {
18698     try {
18699       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18700     } catch (std::out_of_range& e) {
18701       {
18702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18703       };
18704     } catch (std::exception& e) {
18705       {
18706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18707       };
18708     } catch (...) {
18709       {
18710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18711       };
18712     }
18713   }
18714   jresult = SWIG_csharp_string_callback(result->c_str());
18715   return jresult;
18716 }
18717
18718
18719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18720   void * jresult ;
18721   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18722   Dali::BaseHandle result;
18723
18724   arg1 = (Dali::TypeInfo *)jarg1;
18725   {
18726     try {
18727       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18728     } catch (std::out_of_range& e) {
18729       {
18730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (std::exception& e) {
18733       {
18734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (...) {
18737       {
18738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18739       };
18740     }
18741   }
18742   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18743   return jresult;
18744 }
18745
18746
18747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18748   unsigned long jresult ;
18749   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18750   size_t result;
18751
18752   arg1 = (Dali::TypeInfo *)jarg1;
18753   {
18754     try {
18755       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18756     } catch (std::out_of_range& e) {
18757       {
18758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18759       };
18760     } catch (std::exception& e) {
18761       {
18762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (...) {
18765       {
18766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18767       };
18768     }
18769   }
18770   jresult = (unsigned long)result;
18771   return jresult;
18772 }
18773
18774
18775 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18776   char * jresult ;
18777   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18778   size_t arg2 ;
18779   std::string result;
18780
18781   arg1 = (Dali::TypeInfo *)jarg1;
18782   arg2 = (size_t)jarg2;
18783   {
18784     try {
18785       result = (arg1)->GetActionName(arg2);
18786     } catch (std::out_of_range& e) {
18787       {
18788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18789       };
18790     } catch (std::exception& e) {
18791       {
18792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18793       };
18794     } catch (...) {
18795       {
18796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18797       };
18798     }
18799   }
18800   jresult = SWIG_csharp_string_callback((&result)->c_str());
18801   return jresult;
18802 }
18803
18804
18805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18806   unsigned long jresult ;
18807   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18808   size_t result;
18809
18810   arg1 = (Dali::TypeInfo *)jarg1;
18811   {
18812     try {
18813       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18814     } catch (std::out_of_range& e) {
18815       {
18816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (std::exception& e) {
18819       {
18820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (...) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18825       };
18826     }
18827   }
18828   jresult = (unsigned long)result;
18829   return jresult;
18830 }
18831
18832
18833 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18834   char * jresult ;
18835   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18836   size_t arg2 ;
18837   std::string result;
18838
18839   arg1 = (Dali::TypeInfo *)jarg1;
18840   arg2 = (size_t)jarg2;
18841   {
18842     try {
18843       result = (arg1)->GetSignalName(arg2);
18844     } catch (std::out_of_range& e) {
18845       {
18846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18847       };
18848     } catch (std::exception& e) {
18849       {
18850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18851       };
18852     } catch (...) {
18853       {
18854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18855       };
18856     }
18857   }
18858   jresult = SWIG_csharp_string_callback((&result)->c_str());
18859   return jresult;
18860 }
18861
18862
18863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18864   unsigned long jresult ;
18865   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18866   size_t result;
18867
18868   arg1 = (Dali::TypeInfo *)jarg1;
18869   {
18870     try {
18871       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18872     } catch (std::out_of_range& e) {
18873       {
18874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18875       };
18876     } catch (std::exception& e) {
18877       {
18878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18879       };
18880     } catch (...) {
18881       {
18882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18883       };
18884     }
18885   }
18886   jresult = (unsigned long)result;
18887   return jresult;
18888 }
18889
18890
18891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18892   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18893   Dali::Property::IndexContainer *arg2 = 0 ;
18894
18895   arg1 = (Dali::TypeInfo *)jarg1;
18896   arg2 = (Dali::Property::IndexContainer *)jarg2;
18897   if (!arg2) {
18898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18899     return ;
18900   }
18901   {
18902     try {
18903       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18911       };
18912     } catch (...) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18915       };
18916     }
18917   }
18918 }
18919
18920
18921 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18922   char * jresult ;
18923   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18924   Dali::Property::Index arg2 ;
18925   std::string *result = 0 ;
18926
18927   arg1 = (Dali::TypeInfo *)jarg1;
18928   arg2 = (Dali::Property::Index)jarg2;
18929   {
18930     try {
18931       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18932     } catch (std::out_of_range& e) {
18933       {
18934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18935       };
18936     } catch (std::exception& e) {
18937       {
18938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18939       };
18940     } catch (...) {
18941       {
18942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18943       };
18944     }
18945   }
18946   jresult = SWIG_csharp_string_callback(result->c_str());
18947   return jresult;
18948 }
18949
18950
18951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18952   void * jresult ;
18953   Dali::TypeRegistry result;
18954
18955   {
18956     try {
18957       result = Dali::TypeRegistry::Get();
18958     } catch (std::out_of_range& e) {
18959       {
18960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18961       };
18962     } catch (std::exception& e) {
18963       {
18964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18965       };
18966     } catch (...) {
18967       {
18968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18969       };
18970     }
18971   }
18972   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18973   return jresult;
18974 }
18975
18976
18977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18978   void * jresult ;
18979   Dali::TypeRegistry *result = 0 ;
18980
18981   {
18982     try {
18983       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18984     } catch (std::out_of_range& e) {
18985       {
18986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18987       };
18988     } catch (std::exception& e) {
18989       {
18990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18991       };
18992     } catch (...) {
18993       {
18994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18995       };
18996     }
18997   }
18998   jresult = (void *)result;
18999   return jresult;
19000 }
19001
19002
19003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19004   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19005
19006   arg1 = (Dali::TypeRegistry *)jarg1;
19007   {
19008     try {
19009       delete arg1;
19010     } catch (std::out_of_range& e) {
19011       {
19012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (std::exception& e) {
19015       {
19016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024 }
19025
19026
19027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19028   void * jresult ;
19029   Dali::TypeRegistry *arg1 = 0 ;
19030   Dali::TypeRegistry *result = 0 ;
19031
19032   arg1 = (Dali::TypeRegistry *)jarg1;
19033   if (!arg1) {
19034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19035     return 0;
19036   }
19037   {
19038     try {
19039       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19040     } catch (std::out_of_range& e) {
19041       {
19042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19043       };
19044     } catch (std::exception& e) {
19045       {
19046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19047       };
19048     } catch (...) {
19049       {
19050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19051       };
19052     }
19053   }
19054   jresult = (void *)result;
19055   return jresult;
19056 }
19057
19058
19059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19060   void * jresult ;
19061   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19062   Dali::TypeRegistry *arg2 = 0 ;
19063   Dali::TypeRegistry *result = 0 ;
19064
19065   arg1 = (Dali::TypeRegistry *)jarg1;
19066   arg2 = (Dali::TypeRegistry *)jarg2;
19067   if (!arg2) {
19068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19069     return 0;
19070   }
19071   {
19072     try {
19073       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19074     } catch (std::out_of_range& e) {
19075       {
19076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19077       };
19078     } catch (std::exception& e) {
19079       {
19080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19081       };
19082     } catch (...) {
19083       {
19084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19085       };
19086     }
19087   }
19088   jresult = (void *)result;
19089   return jresult;
19090 }
19091
19092
19093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19094   void * jresult ;
19095   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19096   std::string *arg2 = 0 ;
19097   Dali::TypeInfo result;
19098
19099   arg1 = (Dali::TypeRegistry *)jarg1;
19100   if (!jarg2) {
19101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19102     return 0;
19103   }
19104   std::string arg2_str(jarg2);
19105   arg2 = &arg2_str;
19106   {
19107     try {
19108       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19109     } catch (std::out_of_range& e) {
19110       {
19111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19112       };
19113     } catch (std::exception& e) {
19114       {
19115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19116       };
19117     } catch (...) {
19118       {
19119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19120       };
19121     }
19122   }
19123   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19124
19125   //argout typemap for const std::string&
19126
19127   return jresult;
19128 }
19129
19130
19131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19132   void * jresult ;
19133   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19134   std::type_info *arg2 = 0 ;
19135   Dali::TypeInfo result;
19136
19137   arg1 = (Dali::TypeRegistry *)jarg1;
19138   arg2 = (std::type_info *)jarg2;
19139   if (!arg2) {
19140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19141     return 0;
19142   }
19143   {
19144     try {
19145       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19146     } catch (std::out_of_range& e) {
19147       {
19148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19149       };
19150     } catch (std::exception& e) {
19151       {
19152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19153       };
19154     } catch (...) {
19155       {
19156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19157       };
19158     }
19159   }
19160   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19161   return jresult;
19162 }
19163
19164
19165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19166   unsigned long jresult ;
19167   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19168   size_t result;
19169
19170   arg1 = (Dali::TypeRegistry *)jarg1;
19171   {
19172     try {
19173       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19174     } catch (std::out_of_range& e) {
19175       {
19176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19177       };
19178     } catch (std::exception& e) {
19179       {
19180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19181       };
19182     } catch (...) {
19183       {
19184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19185       };
19186     }
19187   }
19188   jresult = (unsigned long)result;
19189   return jresult;
19190 }
19191
19192
19193 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19194   char * jresult ;
19195   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19196   size_t arg2 ;
19197   std::string result;
19198
19199   arg1 = (Dali::TypeRegistry *)jarg1;
19200   arg2 = (size_t)jarg2;
19201   {
19202     try {
19203       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19204     } catch (std::out_of_range& e) {
19205       {
19206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19207       };
19208     } catch (std::exception& e) {
19209       {
19210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19211       };
19212     } catch (...) {
19213       {
19214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19215       };
19216     }
19217   }
19218   jresult = SWIG_csharp_string_callback((&result)->c_str());
19219   return jresult;
19220 }
19221
19222
19223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19224   void * jresult ;
19225   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19226   Dali::TypeRegistry *result = 0 ;
19227
19228   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19229   {
19230     try {
19231       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19232     } catch (std::out_of_range& e) {
19233       {
19234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (std::exception& e) {
19237       {
19238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19239       };
19240     } catch (...) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19243       };
19244     }
19245   }
19246   jresult = (void *)result;
19247   return jresult;
19248 }
19249
19250
19251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19252   void * jresult ;
19253   std::type_info *arg1 = 0 ;
19254   std::type_info *arg2 = 0 ;
19255   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19256   Dali::TypeRegistration *result = 0 ;
19257
19258   arg1 = (std::type_info *)jarg1;
19259   if (!arg1) {
19260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19261     return 0;
19262   }
19263   arg2 = (std::type_info *)jarg2;
19264   if (!arg2) {
19265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19266     return 0;
19267   }
19268   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19269   {
19270     try {
19271       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19272     } catch (std::out_of_range& e) {
19273       {
19274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19275       };
19276     } catch (std::exception& e) {
19277       {
19278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19279       };
19280     } catch (...) {
19281       {
19282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19283       };
19284     }
19285   }
19286   jresult = (void *)result;
19287   return jresult;
19288 }
19289
19290
19291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19292   void * jresult ;
19293   std::type_info *arg1 = 0 ;
19294   std::type_info *arg2 = 0 ;
19295   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19296   bool arg4 ;
19297   Dali::TypeRegistration *result = 0 ;
19298
19299   arg1 = (std::type_info *)jarg1;
19300   if (!arg1) {
19301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19302     return 0;
19303   }
19304   arg2 = (std::type_info *)jarg2;
19305   if (!arg2) {
19306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19307     return 0;
19308   }
19309   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19310   arg4 = jarg4 ? true : false;
19311   {
19312     try {
19313       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (...) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19325       };
19326     }
19327   }
19328   jresult = (void *)result;
19329   return jresult;
19330 }
19331
19332
19333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19334   void * jresult ;
19335   std::string *arg1 = 0 ;
19336   std::type_info *arg2 = 0 ;
19337   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19338   Dali::TypeRegistration *result = 0 ;
19339
19340   if (!jarg1) {
19341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19342     return 0;
19343   }
19344   std::string arg1_str(jarg1);
19345   arg1 = &arg1_str;
19346   arg2 = (std::type_info *)jarg2;
19347   if (!arg2) {
19348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19349     return 0;
19350   }
19351   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19352   {
19353     try {
19354       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19355     } catch (std::out_of_range& e) {
19356       {
19357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19358       };
19359     } catch (std::exception& e) {
19360       {
19361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (...) {
19364       {
19365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19366       };
19367     }
19368   }
19369   jresult = (void *)result;
19370
19371   //argout typemap for const std::string&
19372
19373   return jresult;
19374 }
19375
19376
19377 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19378   char * jresult ;
19379   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19380   std::string result;
19381
19382   arg1 = (Dali::TypeRegistration *)jarg1;
19383   {
19384     try {
19385       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19386     } catch (std::out_of_range& e) {
19387       {
19388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19389       };
19390     } catch (std::exception& e) {
19391       {
19392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (...) {
19395       {
19396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19397       };
19398     }
19399   }
19400   jresult = SWIG_csharp_string_callback((&result)->c_str());
19401   return jresult;
19402 }
19403
19404
19405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19406   std::string *arg1 = 0 ;
19407   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19408
19409   if (!jarg1) {
19410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19411     return ;
19412   }
19413   std::string arg1_str(jarg1);
19414   arg1 = &arg1_str;
19415   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19416   {
19417     try {
19418       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19426       };
19427     } catch (...) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19430       };
19431     }
19432   }
19433
19434   //argout typemap for const std::string&
19435
19436 }
19437
19438
19439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19440   std::string *arg1 = 0 ;
19441   std::string *arg2 = 0 ;
19442   int arg3 ;
19443   Dali::Property::Type arg4 ;
19444   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19445   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19446
19447   if (!jarg1) {
19448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19449     return ;
19450   }
19451   std::string arg1_str(jarg1);
19452   arg1 = &arg1_str;
19453   if (!jarg2) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19455     return ;
19456   }
19457   std::string arg2_str(jarg2);
19458   arg2 = &arg2_str;
19459   arg3 = (int)jarg3;
19460   arg4 = (Dali::Property::Type)jarg4;
19461   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19462   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19463   {
19464     try {
19465       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19466     } catch (std::out_of_range& e) {
19467       {
19468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19469       };
19470     } catch (std::exception& e) {
19471       {
19472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19477       };
19478     }
19479   }
19480
19481   //argout typemap for const std::string&
19482
19483
19484   //argout typemap for const std::string&
19485
19486 }
19487
19488
19489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19490   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19491
19492   arg1 = (Dali::TypeRegistration *)jarg1;
19493   {
19494     try {
19495       delete arg1;
19496     } catch (std::out_of_range& e) {
19497       {
19498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19499       };
19500     } catch (std::exception& e) {
19501       {
19502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19503       };
19504     } catch (...) {
19505       {
19506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19507       };
19508     }
19509   }
19510 }
19511
19512
19513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19514   void * jresult ;
19515   Dali::TypeRegistration *arg1 = 0 ;
19516   std::string *arg2 = 0 ;
19517   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19518   Dali::SignalConnectorType *result = 0 ;
19519
19520   arg1 = (Dali::TypeRegistration *)jarg1;
19521   if (!arg1) {
19522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19523     return 0;
19524   }
19525   if (!jarg2) {
19526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19527     return 0;
19528   }
19529   std::string arg2_str(jarg2);
19530   arg2 = &arg2_str;
19531   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19532   {
19533     try {
19534       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19535     } catch (std::out_of_range& e) {
19536       {
19537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19538       };
19539     } catch (std::exception& e) {
19540       {
19541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19542       };
19543     } catch (...) {
19544       {
19545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19546       };
19547     }
19548   }
19549   jresult = (void *)result;
19550
19551   //argout typemap for const std::string&
19552
19553   return jresult;
19554 }
19555
19556
19557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19558   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19559
19560   arg1 = (Dali::SignalConnectorType *)jarg1;
19561   {
19562     try {
19563       delete arg1;
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19575       };
19576     }
19577   }
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19582   void * jresult ;
19583   Dali::TypeRegistration *arg1 = 0 ;
19584   std::string *arg2 = 0 ;
19585   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19586   Dali::TypeAction *result = 0 ;
19587
19588   arg1 = (Dali::TypeRegistration *)jarg1;
19589   if (!arg1) {
19590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19591     return 0;
19592   }
19593   if (!jarg2) {
19594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19595     return 0;
19596   }
19597   std::string arg2_str(jarg2);
19598   arg2 = &arg2_str;
19599   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19600   {
19601     try {
19602       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19603     } catch (std::out_of_range& e) {
19604       {
19605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19606       };
19607     } catch (std::exception& e) {
19608       {
19609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19610       };
19611     } catch (...) {
19612       {
19613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19614       };
19615     }
19616   }
19617   jresult = (void *)result;
19618
19619   //argout typemap for const std::string&
19620
19621   return jresult;
19622 }
19623
19624
19625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19626   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19627
19628   arg1 = (Dali::TypeAction *)jarg1;
19629   {
19630     try {
19631       delete arg1;
19632     } catch (std::out_of_range& e) {
19633       {
19634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19635       };
19636     } catch (std::exception& e) {
19637       {
19638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19639       };
19640     } catch (...) {
19641       {
19642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19643       };
19644     }
19645   }
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19650   void * jresult ;
19651   Dali::TypeRegistration *arg1 = 0 ;
19652   std::string *arg2 = 0 ;
19653   Dali::Property::Index arg3 ;
19654   Dali::Property::Type arg4 ;
19655   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19656   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19657   Dali::PropertyRegistration *result = 0 ;
19658
19659   arg1 = (Dali::TypeRegistration *)jarg1;
19660   if (!arg1) {
19661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19662     return 0;
19663   }
19664   if (!jarg2) {
19665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19666     return 0;
19667   }
19668   std::string arg2_str(jarg2);
19669   arg2 = &arg2_str;
19670   arg3 = (Dali::Property::Index)jarg3;
19671   arg4 = (Dali::Property::Type)jarg4;
19672   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19673   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19674   {
19675     try {
19676       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19677     } catch (std::out_of_range& e) {
19678       {
19679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19680       };
19681     } catch (std::exception& e) {
19682       {
19683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19684       };
19685     } catch (...) {
19686       {
19687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19688       };
19689     }
19690   }
19691   jresult = (void *)result;
19692
19693   //argout typemap for const std::string&
19694
19695   return jresult;
19696 }
19697
19698
19699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19700   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19701
19702   arg1 = (Dali::PropertyRegistration *)jarg1;
19703   {
19704     try {
19705       delete arg1;
19706     } catch (std::out_of_range& e) {
19707       {
19708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19709       };
19710     } catch (std::exception& e) {
19711       {
19712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19713       };
19714     } catch (...) {
19715       {
19716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19717       };
19718     }
19719   }
19720 }
19721
19722
19723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19724   void * jresult ;
19725   Dali::TypeRegistration *arg1 = 0 ;
19726   std::string *arg2 = 0 ;
19727   Dali::Property::Index arg3 ;
19728   Dali::Property::Type arg4 ;
19729   Dali::AnimatablePropertyRegistration *result = 0 ;
19730
19731   arg1 = (Dali::TypeRegistration *)jarg1;
19732   if (!arg1) {
19733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19734     return 0;
19735   }
19736   if (!jarg2) {
19737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19738     return 0;
19739   }
19740   std::string arg2_str(jarg2);
19741   arg2 = &arg2_str;
19742   arg3 = (Dali::Property::Index)jarg3;
19743   arg4 = (Dali::Property::Type)jarg4;
19744   {
19745     try {
19746       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19747     } catch (std::out_of_range& e) {
19748       {
19749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19750       };
19751     } catch (std::exception& e) {
19752       {
19753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19754       };
19755     } catch (...) {
19756       {
19757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19758       };
19759     }
19760   }
19761   jresult = (void *)result;
19762
19763   //argout typemap for const std::string&
19764
19765   return jresult;
19766 }
19767
19768
19769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19770   void * jresult ;
19771   Dali::TypeRegistration *arg1 = 0 ;
19772   std::string *arg2 = 0 ;
19773   Dali::Property::Index arg3 ;
19774   Dali::Property::Value *arg4 = 0 ;
19775   Dali::AnimatablePropertyRegistration *result = 0 ;
19776
19777   arg1 = (Dali::TypeRegistration *)jarg1;
19778   if (!arg1) {
19779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19780     return 0;
19781   }
19782   if (!jarg2) {
19783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19784     return 0;
19785   }
19786   std::string arg2_str(jarg2);
19787   arg2 = &arg2_str;
19788   arg3 = (Dali::Property::Index)jarg3;
19789   arg4 = (Dali::Property::Value *)jarg4;
19790   if (!arg4) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19792     return 0;
19793   }
19794   {
19795     try {
19796       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (...) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19808       };
19809     }
19810   }
19811   jresult = (void *)result;
19812
19813   //argout typemap for const std::string&
19814
19815   return jresult;
19816 }
19817
19818
19819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19820   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19821
19822   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19823   {
19824     try {
19825       delete arg1;
19826     } catch (std::out_of_range& e) {
19827       {
19828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19829       };
19830     } catch (std::exception& e) {
19831       {
19832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19833       };
19834     } catch (...) {
19835       {
19836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19837       };
19838     }
19839   }
19840 }
19841
19842
19843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19844   void * jresult ;
19845   Dali::TypeRegistration *arg1 = 0 ;
19846   std::string *arg2 = 0 ;
19847   Dali::Property::Index arg3 ;
19848   Dali::Property::Index arg4 ;
19849   unsigned int arg5 ;
19850   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19851
19852   arg1 = (Dali::TypeRegistration *)jarg1;
19853   if (!arg1) {
19854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19855     return 0;
19856   }
19857   if (!jarg2) {
19858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19859     return 0;
19860   }
19861   std::string arg2_str(jarg2);
19862   arg2 = &arg2_str;
19863   arg3 = (Dali::Property::Index)jarg3;
19864   arg4 = (Dali::Property::Index)jarg4;
19865   arg5 = (unsigned int)jarg5;
19866   {
19867     try {
19868       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19869     } catch (std::out_of_range& e) {
19870       {
19871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (std::exception& e) {
19874       {
19875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883   jresult = (void *)result;
19884
19885   //argout typemap for const std::string&
19886
19887   return jresult;
19888 }
19889
19890
19891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19892   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19893
19894   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19895   {
19896     try {
19897       delete arg1;
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (...) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19909       };
19910     }
19911   }
19912 }
19913
19914
19915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19916   void * jresult ;
19917   Dali::TypeRegistration *arg1 = 0 ;
19918   std::string *arg2 = 0 ;
19919   Dali::Property::Index arg3 ;
19920   Dali::Property::Type arg4 ;
19921   Dali::ChildPropertyRegistration *result = 0 ;
19922
19923   arg1 = (Dali::TypeRegistration *)jarg1;
19924   if (!arg1) {
19925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19926     return 0;
19927   }
19928   if (!jarg2) {
19929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19930     return 0;
19931   }
19932   std::string arg2_str(jarg2);
19933   arg2 = &arg2_str;
19934   arg3 = (Dali::Property::Index)jarg3;
19935   arg4 = (Dali::Property::Type)jarg4;
19936   {
19937     try {
19938       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19939     } catch (std::out_of_range& e) {
19940       {
19941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19942       };
19943     } catch (std::exception& e) {
19944       {
19945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19946       };
19947     } catch (...) {
19948       {
19949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19950       };
19951     }
19952   }
19953   jresult = (void *)result;
19954
19955   //argout typemap for const std::string&
19956
19957   return jresult;
19958 }
19959
19960
19961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19962   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19963
19964   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19965   {
19966     try {
19967       delete arg1;
19968     } catch (std::out_of_range& e) {
19969       {
19970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19971       };
19972     } catch (std::exception& e) {
19973       {
19974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19975       };
19976     } catch (...) {
19977       {
19978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19979       };
19980     }
19981   }
19982 }
19983
19984
19985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19986   unsigned int jresult ;
19987   std::string *arg1 = 0 ;
19988   std::type_info *arg2 = 0 ;
19989   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19990   bool result;
19991
19992   if (!jarg1) {
19993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19994     return 0;
19995   }
19996   std::string arg1_str(jarg1);
19997   arg1 = &arg1_str;
19998   arg2 = (std::type_info *)jarg2;
19999   if (!arg2) {
20000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20001     return 0;
20002   }
20003   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20004   {
20005     try {
20006       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20007     } catch (std::out_of_range& e) {
20008       {
20009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20010       };
20011     } catch (std::exception& e) {
20012       {
20013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20014       };
20015     } catch (...) {
20016       {
20017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20018       };
20019     }
20020   }
20021   jresult = result;
20022
20023   //argout typemap for const std::string&
20024
20025   return jresult;
20026 }
20027
20028
20029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20030   unsigned int jresult ;
20031   std::string *arg1 = 0 ;
20032   std::string *arg2 = 0 ;
20033   Dali::Property::Index arg3 ;
20034   Dali::Property::Type arg4 ;
20035   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20036   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20037   bool result;
20038
20039   if (!jarg1) {
20040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20041     return 0;
20042   }
20043   std::string arg1_str(jarg1);
20044   arg1 = &arg1_str;
20045   if (!jarg2) {
20046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20047     return 0;
20048   }
20049   std::string arg2_str(jarg2);
20050   arg2 = &arg2_str;
20051   arg3 = (Dali::Property::Index)jarg3;
20052   arg4 = (Dali::Property::Type)jarg4;
20053   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20054   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20055   {
20056     try {
20057       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20058     } catch (std::out_of_range& e) {
20059       {
20060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20061       };
20062     } catch (std::exception& e) {
20063       {
20064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (...) {
20067       {
20068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20069       };
20070     }
20071   }
20072   jresult = result;
20073
20074   //argout typemap for const std::string&
20075
20076
20077   //argout typemap for const std::string&
20078
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20084   float jresult ;
20085   float result;
20086
20087   result = (float)(float)Dali::ParentOrigin::TOP;
20088   jresult = result;
20089   return jresult;
20090 }
20091
20092
20093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20094   float jresult ;
20095   float result;
20096
20097   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20098   jresult = result;
20099   return jresult;
20100 }
20101
20102
20103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20104   float jresult ;
20105   float result;
20106
20107   result = (float)(float)Dali::ParentOrigin::LEFT;
20108   jresult = result;
20109   return jresult;
20110 }
20111
20112
20113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20114   float jresult ;
20115   float result;
20116
20117   result = (float)(float)Dali::ParentOrigin::RIGHT;
20118   jresult = result;
20119   return jresult;
20120 }
20121
20122
20123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20124   float jresult ;
20125   float result;
20126
20127   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20128   jresult = result;
20129   return jresult;
20130 }
20131
20132
20133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20134   void * jresult ;
20135   Dali::Vector3 *result = 0 ;
20136
20137   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20138   jresult = (void *)result;
20139   return jresult;
20140 }
20141
20142
20143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20144   void * jresult ;
20145   Dali::Vector3 *result = 0 ;
20146
20147   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20148   jresult = (void *)result;
20149   return jresult;
20150 }
20151
20152
20153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20154   void * jresult ;
20155   Dali::Vector3 *result = 0 ;
20156
20157   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20158   jresult = (void *)result;
20159   return jresult;
20160 }
20161
20162
20163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20164   void * jresult ;
20165   Dali::Vector3 *result = 0 ;
20166
20167   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20168   jresult = (void *)result;
20169   return jresult;
20170 }
20171
20172
20173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20174   void * jresult ;
20175   Dali::Vector3 *result = 0 ;
20176
20177   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20178   jresult = (void *)result;
20179   return jresult;
20180 }
20181
20182
20183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20184   void * jresult ;
20185   Dali::Vector3 *result = 0 ;
20186
20187   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20188   jresult = (void *)result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20194   void * jresult ;
20195   Dali::Vector3 *result = 0 ;
20196
20197   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20198   jresult = (void *)result;
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20204   void * jresult ;
20205   Dali::Vector3 *result = 0 ;
20206
20207   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20208   jresult = (void *)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20214   void * jresult ;
20215   Dali::Vector3 *result = 0 ;
20216
20217   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20218   jresult = (void *)result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20224   float jresult ;
20225   float result;
20226
20227   result = (float)(float)Dali::AnchorPoint::TOP;
20228   jresult = result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20234   float jresult ;
20235   float result;
20236
20237   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20238   jresult = result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20244   float jresult ;
20245   float result;
20246
20247   result = (float)(float)Dali::AnchorPoint::LEFT;
20248   jresult = result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20254   float jresult ;
20255   float result;
20256
20257   result = (float)(float)Dali::AnchorPoint::RIGHT;
20258   jresult = result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20264   float jresult ;
20265   float result;
20266
20267   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20268   jresult = result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20284   void * jresult ;
20285   Dali::Vector3 *result = 0 ;
20286
20287   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20294   void * jresult ;
20295   Dali::Vector3 *result = 0 ;
20296
20297   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20304   void * jresult ;
20305   Dali::Vector3 *result = 0 ;
20306
20307   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20314   void * jresult ;
20315   Dali::Vector3 *result = 0 ;
20316
20317   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20318   jresult = (void *)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20324   void * jresult ;
20325   Dali::Vector3 *result = 0 ;
20326
20327   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20344   void * jresult ;
20345   Dali::Vector3 *result = 0 ;
20346
20347   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20348   jresult = (void *)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20354   void * jresult ;
20355   Dali::Vector3 *result = 0 ;
20356
20357   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20358   jresult = (void *)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20364   void * jresult ;
20365   Dali::Vector4 *result = 0 ;
20366
20367   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20368   jresult = (void *)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20374   void * jresult ;
20375   Dali::Vector4 *result = 0 ;
20376
20377   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20378   jresult = (void *)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20384   void * jresult ;
20385   Dali::Vector4 *result = 0 ;
20386
20387   result = (Dali::Vector4 *)&Dali::Color::RED;
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20394   void * jresult ;
20395   Dali::Vector4 *result = 0 ;
20396
20397   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20404   void * jresult ;
20405   Dali::Vector4 *result = 0 ;
20406
20407   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20414   void * jresult ;
20415   Dali::Vector4 *result = 0 ;
20416
20417   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20424   void * jresult ;
20425   Dali::Vector4 *result = 0 ;
20426
20427   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20434   void * jresult ;
20435   Dali::Vector4 *result = 0 ;
20436
20437   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20444   void * jresult ;
20445   Dali::Vector4 *result = 0 ;
20446
20447   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20454   float jresult ;
20455   float result;
20456
20457   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20458   jresult = result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20464   float jresult ;
20465   float result;
20466
20467   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20468   jresult = result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20474   float jresult ;
20475   float result;
20476
20477   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20478   jresult = result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20484   float jresult ;
20485   float result;
20486
20487   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20488   jresult = result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20494   float jresult ;
20495   float result;
20496
20497   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20498   jresult = result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20504   float jresult ;
20505   float result;
20506
20507   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20508   jresult = result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20514   float jresult ;
20515   float result;
20516
20517   result = (float)(float)Dali::Math::PI;
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20524   float jresult ;
20525   float result;
20526
20527   result = (float)(float)Dali::Math::PI_2;
20528   jresult = result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20534   float jresult ;
20535   float result;
20536
20537   result = (float)(float)Dali::Math::PI_4;
20538   jresult = result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20544   float jresult ;
20545   float result;
20546
20547   result = (float)(float)Dali::Math::PI_OVER_180;
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20554   float jresult ;
20555   float result;
20556
20557   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20558   jresult = result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20564   int jresult ;
20565   Dali::ResizePolicy::Type result;
20566
20567   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20568   jresult = (int)result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20574   unsigned long jresult ;
20575   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20576   Dali::VectorBase::SizeType result;
20577
20578   arg1 = (Dali::VectorBase *)jarg1;
20579   {
20580     try {
20581       result = ((Dali::VectorBase const *)arg1)->Count();
20582     } catch (std::out_of_range& e) {
20583       {
20584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20585       };
20586     } catch (std::exception& e) {
20587       {
20588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20589       };
20590     } catch (...) {
20591       {
20592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20593       };
20594     }
20595   }
20596   jresult = (unsigned long)result;
20597   return jresult;
20598 }
20599
20600
20601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20602   unsigned long jresult ;
20603   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20604   Dali::VectorBase::SizeType result;
20605
20606   arg1 = (Dali::VectorBase *)jarg1;
20607   {
20608     try {
20609       result = ((Dali::VectorBase const *)arg1)->Size();
20610     } catch (std::out_of_range& e) {
20611       {
20612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20613       };
20614     } catch (std::exception& e) {
20615       {
20616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20617       };
20618     } catch (...) {
20619       {
20620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20621       };
20622     }
20623   }
20624   jresult = (unsigned long)result;
20625   return jresult;
20626 }
20627
20628
20629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20630   unsigned int jresult ;
20631   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20632   bool result;
20633
20634   arg1 = (Dali::VectorBase *)jarg1;
20635   {
20636     try {
20637       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20638     } catch (std::out_of_range& e) {
20639       {
20640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20641       };
20642     } catch (std::exception& e) {
20643       {
20644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (...) {
20647       {
20648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20649       };
20650     }
20651   }
20652   jresult = result;
20653   return jresult;
20654 }
20655
20656
20657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20658   unsigned long jresult ;
20659   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20660   Dali::VectorBase::SizeType result;
20661
20662   arg1 = (Dali::VectorBase *)jarg1;
20663   {
20664     try {
20665       result = ((Dali::VectorBase const *)arg1)->Capacity();
20666     } catch (std::out_of_range& e) {
20667       {
20668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20669       };
20670     } catch (std::exception& e) {
20671       {
20672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20673       };
20674     } catch (...) {
20675       {
20676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20677       };
20678     }
20679   }
20680   jresult = (unsigned long)result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20686   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20687
20688   arg1 = (Dali::VectorBase *)jarg1;
20689   {
20690     try {
20691       (arg1)->Release();
20692     } catch (std::out_of_range& e) {
20693       {
20694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20695       };
20696     } catch (std::exception& e) {
20697       {
20698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20703       };
20704     }
20705   }
20706 }
20707
20708
20709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20710   void * jresult ;
20711   Dali::Image *result = 0 ;
20712
20713   {
20714     try {
20715       result = (Dali::Image *)new Dali::Image();
20716     } catch (std::out_of_range& e) {
20717       {
20718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (std::exception& e) {
20721       {
20722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730   jresult = (void *)result;
20731   return jresult;
20732 }
20733
20734
20735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20736   Dali::Image *arg1 = (Dali::Image *) 0 ;
20737
20738   arg1 = (Dali::Image *)jarg1;
20739   {
20740     try {
20741       delete arg1;
20742     } catch (std::out_of_range& e) {
20743       {
20744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20745       };
20746     } catch (std::exception& e) {
20747       {
20748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20749       };
20750     } catch (...) {
20751       {
20752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20753       };
20754     }
20755   }
20756 }
20757
20758
20759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20760   void * jresult ;
20761   Dali::Image *arg1 = 0 ;
20762   Dali::Image *result = 0 ;
20763
20764   arg1 = (Dali::Image *)jarg1;
20765   if (!arg1) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20767     return 0;
20768   }
20769   {
20770     try {
20771       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20772     } catch (std::out_of_range& e) {
20773       {
20774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20775       };
20776     } catch (std::exception& e) {
20777       {
20778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20779       };
20780     } catch (...) {
20781       {
20782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20783       };
20784     }
20785   }
20786   jresult = (void *)result;
20787   return jresult;
20788 }
20789
20790
20791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20792   void * jresult ;
20793   Dali::Image *arg1 = (Dali::Image *) 0 ;
20794   Dali::Image *arg2 = 0 ;
20795   Dali::Image *result = 0 ;
20796
20797   arg1 = (Dali::Image *)jarg1;
20798   arg2 = (Dali::Image *)jarg2;
20799   if (!arg2) {
20800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20801     return 0;
20802   }
20803   {
20804     try {
20805       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20806     } catch (std::out_of_range& e) {
20807       {
20808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20809       };
20810     } catch (std::exception& e) {
20811       {
20812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20813       };
20814     } catch (...) {
20815       {
20816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20817       };
20818     }
20819   }
20820   jresult = (void *)result;
20821   return jresult;
20822 }
20823
20824
20825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20826   void * jresult ;
20827   Dali::BaseHandle arg1 ;
20828   Dali::BaseHandle *argp1 ;
20829   Dali::Image result;
20830
20831   argp1 = (Dali::BaseHandle *)jarg1;
20832   if (!argp1) {
20833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20834     return 0;
20835   }
20836   arg1 = *argp1;
20837   {
20838     try {
20839       result = Dali::Image::DownCast(arg1);
20840     } catch (std::out_of_range& e) {
20841       {
20842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20843       };
20844     } catch (std::exception& e) {
20845       {
20846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20847       };
20848     } catch (...) {
20849       {
20850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20851       };
20852     }
20853   }
20854   jresult = new Dali::Image((const Dali::Image &)result);
20855   return jresult;
20856 }
20857
20858
20859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20860   unsigned int jresult ;
20861   Dali::Image *arg1 = (Dali::Image *) 0 ;
20862   unsigned int result;
20863
20864   arg1 = (Dali::Image *)jarg1;
20865   {
20866     try {
20867       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (...) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20879       };
20880     }
20881   }
20882   jresult = result;
20883   return jresult;
20884 }
20885
20886
20887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20888   unsigned int jresult ;
20889   Dali::Image *arg1 = (Dali::Image *) 0 ;
20890   unsigned int result;
20891
20892   arg1 = (Dali::Image *)jarg1;
20893   {
20894     try {
20895       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20896     } catch (std::out_of_range& e) {
20897       {
20898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20899       };
20900     } catch (std::exception& e) {
20901       {
20902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (...) {
20905       {
20906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20907       };
20908     }
20909   }
20910   jresult = result;
20911   return jresult;
20912 }
20913
20914
20915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20916   void * jresult ;
20917   Dali::Image *arg1 = (Dali::Image *) 0 ;
20918   Dali::Image::ImageSignalType *result = 0 ;
20919
20920   arg1 = (Dali::Image *)jarg1;
20921   {
20922     try {
20923       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20924     } catch (std::out_of_range& e) {
20925       {
20926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20927       };
20928     } catch (std::exception& e) {
20929       {
20930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20931       };
20932     } catch (...) {
20933       {
20934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20935       };
20936     }
20937   }
20938   jresult = (void *)result;
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20944   int jresult ;
20945   Dali::Pixel::Format result;
20946
20947   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20948   jresult = (int)result;
20949   return jresult;
20950 }
20951
20952
20953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20954   int jresult ;
20955   Dali::Pixel::Format result;
20956
20957   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20958   jresult = (int)result;
20959   return jresult;
20960 }
20961
20962
20963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20964   unsigned int jresult ;
20965   Dali::Pixel::Format arg1 ;
20966   bool result;
20967
20968   arg1 = (Dali::Pixel::Format)jarg1;
20969   {
20970     try {
20971       result = (bool)Dali::Pixel::HasAlpha(arg1);
20972     } catch (std::out_of_range& e) {
20973       {
20974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20975       };
20976     } catch (std::exception& e) {
20977       {
20978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20979       };
20980     } catch (...) {
20981       {
20982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20983       };
20984     }
20985   }
20986   jresult = result;
20987   return jresult;
20988 }
20989
20990
20991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20992   unsigned int jresult ;
20993   Dali::Pixel::Format arg1 ;
20994   unsigned int result;
20995
20996   arg1 = (Dali::Pixel::Format)jarg1;
20997   {
20998     try {
20999       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21000     } catch (std::out_of_range& e) {
21001       {
21002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21003       };
21004     } catch (std::exception& e) {
21005       {
21006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21007       };
21008     } catch (...) {
21009       {
21010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21011       };
21012     }
21013   }
21014   jresult = result;
21015   return jresult;
21016 }
21017
21018
21019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21020   Dali::Pixel::Format arg1 ;
21021   int *arg2 = 0 ;
21022   int *arg3 = 0 ;
21023
21024   arg1 = (Dali::Pixel::Format)jarg1;
21025   arg2 = (int *)jarg2;
21026   if (!arg2) {
21027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21028     return ;
21029   }
21030   arg3 = (int *)jarg3;
21031   if (!arg3) {
21032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21033     return ;
21034   }
21035   {
21036     try {
21037       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21038     } catch (std::out_of_range& e) {
21039       {
21040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21041       };
21042     } catch (std::exception& e) {
21043       {
21044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21045       };
21046     } catch (...) {
21047       {
21048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21049       };
21050     }
21051   }
21052 }
21053
21054
21055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21056   void * jresult ;
21057   unsigned char *arg1 = (unsigned char *) 0 ;
21058   unsigned int arg2 ;
21059   unsigned int arg3 ;
21060   unsigned int arg4 ;
21061   Dali::Pixel::Format arg5 ;
21062   Dali::PixelData::ReleaseFunction arg6 ;
21063   Dali::PixelData result;
21064
21065   arg1 = jarg1;
21066   arg2 = (unsigned int)jarg2;
21067   arg3 = (unsigned int)jarg3;
21068   arg4 = (unsigned int)jarg4;
21069   arg5 = (Dali::Pixel::Format)jarg5;
21070   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21071   {
21072     try {
21073       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21074     } catch (std::out_of_range& e) {
21075       {
21076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21077       };
21078     } catch (std::exception& e) {
21079       {
21080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21081       };
21082     } catch (...) {
21083       {
21084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21085       };
21086     }
21087   }
21088   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21089
21090
21091   return jresult;
21092 }
21093
21094
21095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21096   void * jresult ;
21097   Dali::PixelData *result = 0 ;
21098
21099   {
21100     try {
21101       result = (Dali::PixelData *)new Dali::PixelData();
21102     } catch (std::out_of_range& e) {
21103       {
21104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21105       };
21106     } catch (std::exception& e) {
21107       {
21108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21109       };
21110     } catch (...) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21113       };
21114     }
21115   }
21116   jresult = (void *)result;
21117   return jresult;
21118 }
21119
21120
21121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21122   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21123
21124   arg1 = (Dali::PixelData *)jarg1;
21125   {
21126     try {
21127       delete arg1;
21128     } catch (std::out_of_range& e) {
21129       {
21130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21131       };
21132     } catch (std::exception& e) {
21133       {
21134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21135       };
21136     } catch (...) {
21137       {
21138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21139       };
21140     }
21141   }
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21146   void * jresult ;
21147   Dali::PixelData *arg1 = 0 ;
21148   Dali::PixelData *result = 0 ;
21149
21150   arg1 = (Dali::PixelData *)jarg1;
21151   if (!arg1) {
21152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21153     return 0;
21154   }
21155   {
21156     try {
21157       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21158     } catch (std::out_of_range& e) {
21159       {
21160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (std::exception& e) {
21163       {
21164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172   jresult = (void *)result;
21173   return jresult;
21174 }
21175
21176
21177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21178   void * jresult ;
21179   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21180   Dali::PixelData *arg2 = 0 ;
21181   Dali::PixelData *result = 0 ;
21182
21183   arg1 = (Dali::PixelData *)jarg1;
21184   arg2 = (Dali::PixelData *)jarg2;
21185   if (!arg2) {
21186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21187     return 0;
21188   }
21189   {
21190     try {
21191       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21192     } catch (std::out_of_range& e) {
21193       {
21194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21195       };
21196     } catch (std::exception& e) {
21197       {
21198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21199       };
21200     } catch (...) {
21201       {
21202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21203       };
21204     }
21205   }
21206   jresult = (void *)result;
21207   return jresult;
21208 }
21209
21210
21211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21212   unsigned int jresult ;
21213   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21214   unsigned int result;
21215
21216   arg1 = (Dali::PixelData *)jarg1;
21217   {
21218     try {
21219       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21220     } catch (std::out_of_range& e) {
21221       {
21222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21223       };
21224     } catch (std::exception& e) {
21225       {
21226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21231       };
21232     }
21233   }
21234   jresult = result;
21235   return jresult;
21236 }
21237
21238
21239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21240   unsigned int jresult ;
21241   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21242   unsigned int result;
21243
21244   arg1 = (Dali::PixelData *)jarg1;
21245   {
21246     try {
21247       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21255       };
21256     } catch (...) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21259       };
21260     }
21261   }
21262   jresult = result;
21263   return jresult;
21264 }
21265
21266
21267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21268   int jresult ;
21269   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21270   Dali::Pixel::Format result;
21271
21272   arg1 = (Dali::PixelData *)jarg1;
21273   {
21274     try {
21275       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21276     } catch (std::out_of_range& e) {
21277       {
21278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21279       };
21280     } catch (std::exception& e) {
21281       {
21282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21283       };
21284     } catch (...) {
21285       {
21286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21287       };
21288     }
21289   }
21290   jresult = (int)result;
21291   return jresult;
21292 }
21293
21294
21295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21296   unsigned int jresult ;
21297   unsigned int result;
21298
21299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21300   jresult = result;
21301   return jresult;
21302 }
21303
21304
21305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21306   unsigned int jresult ;
21307   unsigned int result;
21308
21309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21310   jresult = result;
21311   return jresult;
21312 }
21313
21314
21315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21316   unsigned int jresult ;
21317   unsigned int result;
21318
21319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21320   jresult = result;
21321   return jresult;
21322 }
21323
21324
21325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21326   unsigned int jresult ;
21327   unsigned int result;
21328
21329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21330   jresult = result;
21331   return jresult;
21332 }
21333
21334
21335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21336   unsigned int jresult ;
21337   unsigned int result;
21338
21339   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21340   jresult = result;
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21346   unsigned int jresult ;
21347   unsigned int result;
21348
21349   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21350   jresult = result;
21351   return jresult;
21352 }
21353
21354
21355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21356   void * jresult ;
21357   Dali::TextureType::Type arg1 ;
21358   Dali::Pixel::Format arg2 ;
21359   unsigned int arg3 ;
21360   unsigned int arg4 ;
21361   Dali::Texture result;
21362
21363   arg1 = (Dali::TextureType::Type)jarg1;
21364   arg2 = (Dali::Pixel::Format)jarg2;
21365   arg3 = (unsigned int)jarg3;
21366   arg4 = (unsigned int)jarg4;
21367   {
21368     try {
21369       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21370     } catch (std::out_of_range& e) {
21371       {
21372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21373       };
21374     } catch (std::exception& e) {
21375       {
21376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (...) {
21379       {
21380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21381       };
21382     }
21383   }
21384   jresult = new Dali::Texture((const Dali::Texture &)result);
21385   return jresult;
21386 }
21387
21388
21389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21390   void * jresult ;
21391   NativeImageInterface *arg1 = 0 ;
21392   Dali::Texture result;
21393
21394   arg1 = (NativeImageInterface *)jarg1;
21395   if (!arg1) {
21396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21397     return 0;
21398   }
21399   {
21400     try {
21401       result = Dali::Texture::New(*arg1);
21402     } catch (std::out_of_range& e) {
21403       {
21404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21405       };
21406     } catch (std::exception& e) {
21407       {
21408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21409       };
21410     } catch (...) {
21411       {
21412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21413       };
21414     }
21415   }
21416   jresult = new Dali::Texture((const Dali::Texture &)result);
21417   return jresult;
21418 }
21419
21420
21421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21422   void * jresult ;
21423   Dali::Texture *result = 0 ;
21424
21425   {
21426     try {
21427       result = (Dali::Texture *)new Dali::Texture();
21428     } catch (std::out_of_range& e) {
21429       {
21430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21431       };
21432     } catch (std::exception& e) {
21433       {
21434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21435       };
21436     } catch (...) {
21437       {
21438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21439       };
21440     }
21441   }
21442   jresult = (void *)result;
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21448   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21449
21450   arg1 = (Dali::Texture *)jarg1;
21451   {
21452     try {
21453       delete arg1;
21454     } catch (std::out_of_range& e) {
21455       {
21456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21457       };
21458     } catch (std::exception& e) {
21459       {
21460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21461       };
21462     } catch (...) {
21463       {
21464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21465       };
21466     }
21467   }
21468 }
21469
21470
21471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21472   void * jresult ;
21473   Dali::Texture *arg1 = 0 ;
21474   Dali::Texture *result = 0 ;
21475
21476   arg1 = (Dali::Texture *)jarg1;
21477   if (!arg1) {
21478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21479     return 0;
21480   }
21481   {
21482     try {
21483       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21484     } catch (std::out_of_range& e) {
21485       {
21486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21487       };
21488     } catch (std::exception& e) {
21489       {
21490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (...) {
21493       {
21494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21495       };
21496     }
21497   }
21498   jresult = (void *)result;
21499   return jresult;
21500 }
21501
21502
21503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21504   void * jresult ;
21505   Dali::BaseHandle arg1 ;
21506   Dali::BaseHandle *argp1 ;
21507   Dali::Texture result;
21508
21509   argp1 = (Dali::BaseHandle *)jarg1;
21510   if (!argp1) {
21511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21512     return 0;
21513   }
21514   arg1 = *argp1;
21515   {
21516     try {
21517       result = Dali::Texture::DownCast(arg1);
21518     } catch (std::out_of_range& e) {
21519       {
21520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21521       };
21522     } catch (std::exception& e) {
21523       {
21524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (...) {
21527       {
21528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21529       };
21530     }
21531   }
21532   jresult = new Dali::Texture((const Dali::Texture &)result);
21533   return jresult;
21534 }
21535
21536
21537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21538   void * jresult ;
21539   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21540   Dali::Texture *arg2 = 0 ;
21541   Dali::Texture *result = 0 ;
21542
21543   arg1 = (Dali::Texture *)jarg1;
21544   arg2 = (Dali::Texture *)jarg2;
21545   if (!arg2) {
21546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21547     return 0;
21548   }
21549   {
21550     try {
21551       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21552     } catch (std::out_of_range& e) {
21553       {
21554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (std::exception& e) {
21557       {
21558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (...) {
21561       {
21562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21563       };
21564     }
21565   }
21566   jresult = (void *)result;
21567   return jresult;
21568 }
21569
21570
21571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21572   unsigned int jresult ;
21573   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21574   Dali::PixelData arg2 ;
21575   Dali::PixelData *argp2 ;
21576   bool result;
21577
21578   arg1 = (Dali::Texture *)jarg1;
21579   argp2 = (Dali::PixelData *)jarg2;
21580   if (!argp2) {
21581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21582     return 0;
21583   }
21584   arg2 = *argp2;
21585   {
21586     try {
21587       result = (bool)(arg1)->Upload(arg2);
21588     } catch (std::out_of_range& e) {
21589       {
21590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21591       };
21592     } catch (std::exception& e) {
21593       {
21594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21595       };
21596     } catch (...) {
21597       {
21598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21599       };
21600     }
21601   }
21602   jresult = result;
21603   return jresult;
21604 }
21605
21606
21607 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) {
21608   unsigned int jresult ;
21609   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21610   Dali::PixelData arg2 ;
21611   unsigned int arg3 ;
21612   unsigned int arg4 ;
21613   unsigned int arg5 ;
21614   unsigned int arg6 ;
21615   unsigned int arg7 ;
21616   unsigned int arg8 ;
21617   Dali::PixelData *argp2 ;
21618   bool result;
21619
21620   arg1 = (Dali::Texture *)jarg1;
21621   argp2 = (Dali::PixelData *)jarg2;
21622   if (!argp2) {
21623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21624     return 0;
21625   }
21626   arg2 = *argp2;
21627   arg3 = (unsigned int)jarg3;
21628   arg4 = (unsigned int)jarg4;
21629   arg5 = (unsigned int)jarg5;
21630   arg6 = (unsigned int)jarg6;
21631   arg7 = (unsigned int)jarg7;
21632   arg8 = (unsigned int)jarg8;
21633   {
21634     try {
21635       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21636     } catch (std::out_of_range& e) {
21637       {
21638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21639       };
21640     } catch (std::exception& e) {
21641       {
21642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21643       };
21644     } catch (...) {
21645       {
21646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21647       };
21648     }
21649   }
21650   jresult = result;
21651   return jresult;
21652 }
21653
21654
21655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21656   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21657
21658   arg1 = (Dali::Texture *)jarg1;
21659   {
21660     try {
21661       (arg1)->GenerateMipmaps();
21662     } catch (std::out_of_range& e) {
21663       {
21664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21665       };
21666     } catch (std::exception& e) {
21667       {
21668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21669       };
21670     } catch (...) {
21671       {
21672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21673       };
21674     }
21675   }
21676 }
21677
21678
21679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21680   unsigned int jresult ;
21681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21682   unsigned int result;
21683
21684   arg1 = (Dali::Texture *)jarg1;
21685   {
21686     try {
21687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (...) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21699       };
21700     }
21701   }
21702   jresult = result;
21703   return jresult;
21704 }
21705
21706
21707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21708   unsigned int jresult ;
21709   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21710   unsigned int result;
21711
21712   arg1 = (Dali::Texture *)jarg1;
21713   {
21714     try {
21715       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21716     } catch (std::out_of_range& e) {
21717       {
21718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21719       };
21720     } catch (std::exception& e) {
21721       {
21722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21723       };
21724     } catch (...) {
21725       {
21726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21727       };
21728     }
21729   }
21730   jresult = result;
21731   return jresult;
21732 }
21733
21734
21735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21736   void * jresult ;
21737   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21738   Dali::Texture *result = 0 ;
21739
21740   arg1 = (Dali::Internal::Texture *)jarg1;
21741   {
21742     try {
21743       result = (Dali::Texture *)new Dali::Texture(arg1);
21744     } catch (std::out_of_range& e) {
21745       {
21746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21747       };
21748     } catch (std::exception& e) {
21749       {
21750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (...) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21755       };
21756     }
21757   }
21758   jresult = (void *)result;
21759   return jresult;
21760 }
21761
21762
21763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21764   void * jresult ;
21765   Dali::Sampler result;
21766
21767   {
21768     try {
21769       result = Dali::Sampler::New();
21770     } catch (std::out_of_range& e) {
21771       {
21772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21773       };
21774     } catch (std::exception& e) {
21775       {
21776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (...) {
21779       {
21780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21781       };
21782     }
21783   }
21784   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21785   return jresult;
21786 }
21787
21788
21789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21790   void * jresult ;
21791   Dali::Sampler *result = 0 ;
21792
21793   {
21794     try {
21795       result = (Dali::Sampler *)new Dali::Sampler();
21796     } catch (std::out_of_range& e) {
21797       {
21798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21799       };
21800     } catch (std::exception& e) {
21801       {
21802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21803       };
21804     } catch (...) {
21805       {
21806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21807       };
21808     }
21809   }
21810   jresult = (void *)result;
21811   return jresult;
21812 }
21813
21814
21815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21816   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21817
21818   arg1 = (Dali::Sampler *)jarg1;
21819   {
21820     try {
21821       delete arg1;
21822     } catch (std::out_of_range& e) {
21823       {
21824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21825       };
21826     } catch (std::exception& e) {
21827       {
21828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21829       };
21830     } catch (...) {
21831       {
21832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21833       };
21834     }
21835   }
21836 }
21837
21838
21839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21840   void * jresult ;
21841   Dali::Sampler *arg1 = 0 ;
21842   Dali::Sampler *result = 0 ;
21843
21844   arg1 = (Dali::Sampler *)jarg1;
21845   if (!arg1) {
21846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21847     return 0;
21848   }
21849   {
21850     try {
21851       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21852     } catch (std::out_of_range& e) {
21853       {
21854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21855       };
21856     } catch (std::exception& e) {
21857       {
21858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21859       };
21860     } catch (...) {
21861       {
21862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21863       };
21864     }
21865   }
21866   jresult = (void *)result;
21867   return jresult;
21868 }
21869
21870
21871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21872   void * jresult ;
21873   Dali::BaseHandle arg1 ;
21874   Dali::BaseHandle *argp1 ;
21875   Dali::Sampler result;
21876
21877   argp1 = (Dali::BaseHandle *)jarg1;
21878   if (!argp1) {
21879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21880     return 0;
21881   }
21882   arg1 = *argp1;
21883   {
21884     try {
21885       result = Dali::Sampler::DownCast(arg1);
21886     } catch (std::out_of_range& e) {
21887       {
21888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21889       };
21890     } catch (std::exception& e) {
21891       {
21892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21893       };
21894     } catch (...) {
21895       {
21896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21897       };
21898     }
21899   }
21900   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21901   return jresult;
21902 }
21903
21904
21905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21906   void * jresult ;
21907   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21908   Dali::Sampler *arg2 = 0 ;
21909   Dali::Sampler *result = 0 ;
21910
21911   arg1 = (Dali::Sampler *)jarg1;
21912   arg2 = (Dali::Sampler *)jarg2;
21913   if (!arg2) {
21914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21915     return 0;
21916   }
21917   {
21918     try {
21919       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21920     } catch (std::out_of_range& e) {
21921       {
21922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21923       };
21924     } catch (std::exception& e) {
21925       {
21926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21927       };
21928     } catch (...) {
21929       {
21930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21931       };
21932     }
21933   }
21934   jresult = (void *)result;
21935   return jresult;
21936 }
21937
21938
21939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21940   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21941   Dali::FilterMode::Type arg2 ;
21942   Dali::FilterMode::Type arg3 ;
21943
21944   arg1 = (Dali::Sampler *)jarg1;
21945   arg2 = (Dali::FilterMode::Type)jarg2;
21946   arg3 = (Dali::FilterMode::Type)jarg3;
21947   {
21948     try {
21949       (arg1)->SetFilterMode(arg2,arg3);
21950     } catch (std::out_of_range& e) {
21951       {
21952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21953       };
21954     } catch (std::exception& e) {
21955       {
21956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21957       };
21958     } catch (...) {
21959       {
21960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21961       };
21962     }
21963   }
21964 }
21965
21966
21967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21968   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21969   Dali::WrapMode::Type arg2 ;
21970   Dali::WrapMode::Type arg3 ;
21971
21972   arg1 = (Dali::Sampler *)jarg1;
21973   arg2 = (Dali::WrapMode::Type)jarg2;
21974   arg3 = (Dali::WrapMode::Type)jarg3;
21975   {
21976     try {
21977       (arg1)->SetWrapMode(arg2,arg3);
21978     } catch (std::out_of_range& e) {
21979       {
21980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21981       };
21982     } catch (std::exception& e) {
21983       {
21984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21985       };
21986     } catch (...) {
21987       {
21988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21989       };
21990     }
21991   }
21992 }
21993
21994
21995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21996   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21997   Dali::WrapMode::Type arg2 ;
21998   Dali::WrapMode::Type arg3 ;
21999   Dali::WrapMode::Type arg4 ;
22000
22001   arg1 = (Dali::Sampler *)jarg1;
22002   arg2 = (Dali::WrapMode::Type)jarg2;
22003   arg3 = (Dali::WrapMode::Type)jarg3;
22004   arg4 = (Dali::WrapMode::Type)jarg4;
22005   {
22006     try {
22007       (arg1)->SetWrapMode(arg2,arg3,arg4);
22008     } catch (std::out_of_range& e) {
22009       {
22010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22011       };
22012     } catch (std::exception& e) {
22013       {
22014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22015       };
22016     } catch (...) {
22017       {
22018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22019       };
22020     }
22021   }
22022 }
22023
22024
22025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22026   void * jresult ;
22027   Dali::TextureSet result;
22028
22029   {
22030     try {
22031       result = Dali::TextureSet::New();
22032     } catch (std::out_of_range& e) {
22033       {
22034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22035       };
22036     } catch (std::exception& e) {
22037       {
22038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22039       };
22040     } catch (...) {
22041       {
22042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22043       };
22044     }
22045   }
22046   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22047   return jresult;
22048 }
22049
22050
22051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22052   void * jresult ;
22053   Dali::TextureSet *result = 0 ;
22054
22055   {
22056     try {
22057       result = (Dali::TextureSet *)new Dali::TextureSet();
22058     } catch (std::out_of_range& e) {
22059       {
22060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22061       };
22062     } catch (std::exception& e) {
22063       {
22064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (...) {
22067       {
22068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22069       };
22070     }
22071   }
22072   jresult = (void *)result;
22073   return jresult;
22074 }
22075
22076
22077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22078   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22079
22080   arg1 = (Dali::TextureSet *)jarg1;
22081   {
22082     try {
22083       delete arg1;
22084     } catch (std::out_of_range& e) {
22085       {
22086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22087       };
22088     } catch (std::exception& e) {
22089       {
22090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22091       };
22092     } catch (...) {
22093       {
22094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22095       };
22096     }
22097   }
22098 }
22099
22100
22101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22102   void * jresult ;
22103   Dali::TextureSet *arg1 = 0 ;
22104   Dali::TextureSet *result = 0 ;
22105
22106   arg1 = (Dali::TextureSet *)jarg1;
22107   if (!arg1) {
22108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22109     return 0;
22110   }
22111   {
22112     try {
22113       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22114     } catch (std::out_of_range& e) {
22115       {
22116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22117       };
22118     } catch (std::exception& e) {
22119       {
22120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22121       };
22122     } catch (...) {
22123       {
22124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22125       };
22126     }
22127   }
22128   jresult = (void *)result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22134   void * jresult ;
22135   Dali::BaseHandle arg1 ;
22136   Dali::BaseHandle *argp1 ;
22137   Dali::TextureSet result;
22138
22139   argp1 = (Dali::BaseHandle *)jarg1;
22140   if (!argp1) {
22141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22142     return 0;
22143   }
22144   arg1 = *argp1;
22145   {
22146     try {
22147       result = Dali::TextureSet::DownCast(arg1);
22148     } catch (std::out_of_range& e) {
22149       {
22150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22151       };
22152     } catch (std::exception& e) {
22153       {
22154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22155       };
22156     } catch (...) {
22157       {
22158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22159       };
22160     }
22161   }
22162   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22163   return jresult;
22164 }
22165
22166
22167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22168   void * jresult ;
22169   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22170   Dali::TextureSet *arg2 = 0 ;
22171   Dali::TextureSet *result = 0 ;
22172
22173   arg1 = (Dali::TextureSet *)jarg1;
22174   arg2 = (Dali::TextureSet *)jarg2;
22175   if (!arg2) {
22176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22177     return 0;
22178   }
22179   {
22180     try {
22181       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22182     } catch (std::out_of_range& e) {
22183       {
22184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22185       };
22186     } catch (std::exception& e) {
22187       {
22188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22189       };
22190     } catch (...) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22193       };
22194     }
22195   }
22196   jresult = (void *)result;
22197   return jresult;
22198 }
22199
22200
22201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22202   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22203   size_t arg2 ;
22204   Dali::Texture arg3 ;
22205   Dali::Texture *argp3 ;
22206
22207   arg1 = (Dali::TextureSet *)jarg1;
22208   arg2 = (size_t)jarg2;
22209   argp3 = (Dali::Texture *)jarg3;
22210   if (!argp3) {
22211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22212     return ;
22213   }
22214   arg3 = *argp3;
22215   {
22216     try {
22217       (arg1)->SetTexture(arg2,arg3);
22218     } catch (std::out_of_range& e) {
22219       {
22220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22221       };
22222     } catch (std::exception& e) {
22223       {
22224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22225       };
22226     } catch (...) {
22227       {
22228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22229       };
22230     }
22231   }
22232 }
22233
22234
22235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22236   void * jresult ;
22237   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22238   size_t arg2 ;
22239   Dali::Texture result;
22240
22241   arg1 = (Dali::TextureSet *)jarg1;
22242   arg2 = (size_t)jarg2;
22243   {
22244     try {
22245       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22246     } catch (std::out_of_range& e) {
22247       {
22248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22249       };
22250     } catch (std::exception& e) {
22251       {
22252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22257       };
22258     }
22259   }
22260   jresult = new Dali::Texture((const Dali::Texture &)result);
22261   return jresult;
22262 }
22263
22264
22265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22266   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22267   size_t arg2 ;
22268   Dali::Sampler arg3 ;
22269   Dali::Sampler *argp3 ;
22270
22271   arg1 = (Dali::TextureSet *)jarg1;
22272   arg2 = (size_t)jarg2;
22273   argp3 = (Dali::Sampler *)jarg3;
22274   if (!argp3) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22276     return ;
22277   }
22278   arg3 = *argp3;
22279   {
22280     try {
22281       (arg1)->SetSampler(arg2,arg3);
22282     } catch (std::out_of_range& e) {
22283       {
22284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22285       };
22286     } catch (std::exception& e) {
22287       {
22288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22289       };
22290     } catch (...) {
22291       {
22292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22293       };
22294     }
22295   }
22296 }
22297
22298
22299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22300   void * jresult ;
22301   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22302   size_t arg2 ;
22303   Dali::Sampler result;
22304
22305   arg1 = (Dali::TextureSet *)jarg1;
22306   arg2 = (size_t)jarg2;
22307   {
22308     try {
22309       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22310     } catch (std::out_of_range& e) {
22311       {
22312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (std::exception& e) {
22315       {
22316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22321       };
22322     }
22323   }
22324   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22325   return jresult;
22326 }
22327
22328
22329 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22330   unsigned long jresult ;
22331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22332   size_t result;
22333
22334   arg1 = (Dali::TextureSet *)jarg1;
22335   {
22336     try {
22337       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22338     } catch (std::out_of_range& e) {
22339       {
22340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22341       };
22342     } catch (std::exception& e) {
22343       {
22344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22345       };
22346     } catch (...) {
22347       {
22348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22349       };
22350     }
22351   }
22352   jresult = (unsigned long)result;
22353   return jresult;
22354 }
22355
22356
22357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22358   void * jresult ;
22359   Dali::Property::Map *arg1 = 0 ;
22360   Dali::PropertyBuffer result;
22361
22362   arg1 = (Dali::Property::Map *)jarg1;
22363   if (!arg1) {
22364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22365     return 0;
22366   }
22367   {
22368     try {
22369       result = Dali::PropertyBuffer::New(*arg1);
22370     } catch (std::out_of_range& e) {
22371       {
22372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (std::exception& e) {
22375       {
22376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22385   return jresult;
22386 }
22387
22388
22389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22390   void * jresult ;
22391   Dali::PropertyBuffer *result = 0 ;
22392
22393   {
22394     try {
22395       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22396     } catch (std::out_of_range& e) {
22397       {
22398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22399       };
22400     } catch (std::exception& e) {
22401       {
22402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22403       };
22404     } catch (...) {
22405       {
22406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22407       };
22408     }
22409   }
22410   jresult = (void *)result;
22411   return jresult;
22412 }
22413
22414
22415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22416   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22417
22418   arg1 = (Dali::PropertyBuffer *)jarg1;
22419   {
22420     try {
22421       delete arg1;
22422     } catch (std::out_of_range& e) {
22423       {
22424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22425       };
22426     } catch (std::exception& e) {
22427       {
22428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22429       };
22430     } catch (...) {
22431       {
22432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22433       };
22434     }
22435   }
22436 }
22437
22438
22439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22440   void * jresult ;
22441   Dali::PropertyBuffer *arg1 = 0 ;
22442   Dali::PropertyBuffer *result = 0 ;
22443
22444   arg1 = (Dali::PropertyBuffer *)jarg1;
22445   if (!arg1) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22447     return 0;
22448   }
22449   {
22450     try {
22451       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22452     } catch (std::out_of_range& e) {
22453       {
22454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (std::exception& e) {
22457       {
22458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466   jresult = (void *)result;
22467   return jresult;
22468 }
22469
22470
22471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22472   void * jresult ;
22473   Dali::BaseHandle arg1 ;
22474   Dali::BaseHandle *argp1 ;
22475   Dali::PropertyBuffer result;
22476
22477   argp1 = (Dali::BaseHandle *)jarg1;
22478   if (!argp1) {
22479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22480     return 0;
22481   }
22482   arg1 = *argp1;
22483   {
22484     try {
22485       result = Dali::PropertyBuffer::DownCast(arg1);
22486     } catch (std::out_of_range& e) {
22487       {
22488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22489       };
22490     } catch (std::exception& e) {
22491       {
22492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22497       };
22498     }
22499   }
22500   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22501   return jresult;
22502 }
22503
22504
22505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22506   void * jresult ;
22507   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22508   Dali::PropertyBuffer *arg2 = 0 ;
22509   Dali::PropertyBuffer *result = 0 ;
22510
22511   arg1 = (Dali::PropertyBuffer *)jarg1;
22512   arg2 = (Dali::PropertyBuffer *)jarg2;
22513   if (!arg2) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22515     return 0;
22516   }
22517   {
22518     try {
22519       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22520     } catch (std::out_of_range& e) {
22521       {
22522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22523       };
22524     } catch (std::exception& e) {
22525       {
22526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22527       };
22528     } catch (...) {
22529       {
22530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22531       };
22532     }
22533   }
22534   jresult = (void *)result;
22535   return jresult;
22536 }
22537
22538
22539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22540   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22541   void *arg2 = (void *) 0 ;
22542   std::size_t arg3 ;
22543
22544   arg1 = (Dali::PropertyBuffer *)jarg1;
22545   arg2 = jarg2;
22546   arg3 = (std::size_t)jarg3;
22547   {
22548     try {
22549       (arg1)->SetData((void const *)arg2,arg3);
22550     } catch (std::out_of_range& e) {
22551       {
22552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22553       };
22554     } catch (std::exception& e) {
22555       {
22556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22557       };
22558     } catch (...) {
22559       {
22560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22561       };
22562     }
22563   }
22564 }
22565
22566
22567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22568   unsigned long jresult ;
22569   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22570   std::size_t result;
22571
22572   arg1 = (Dali::PropertyBuffer *)jarg1;
22573   {
22574     try {
22575       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22576     } catch (std::out_of_range& e) {
22577       {
22578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22579       };
22580     } catch (std::exception& e) {
22581       {
22582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22583       };
22584     } catch (...) {
22585       {
22586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22587       };
22588     }
22589   }
22590   jresult = (unsigned long)result;
22591   return jresult;
22592 }
22593
22594
22595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22596   void * jresult ;
22597   Dali::Geometry result;
22598
22599   {
22600     try {
22601       result = Dali::Geometry::New();
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (...) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22613       };
22614     }
22615   }
22616   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22617   return jresult;
22618 }
22619
22620
22621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22622   void * jresult ;
22623   Dali::Geometry *result = 0 ;
22624
22625   {
22626     try {
22627       result = (Dali::Geometry *)new Dali::Geometry();
22628     } catch (std::out_of_range& e) {
22629       {
22630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22631       };
22632     } catch (std::exception& e) {
22633       {
22634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22635       };
22636     } catch (...) {
22637       {
22638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22639       };
22640     }
22641   }
22642   jresult = (void *)result;
22643   return jresult;
22644 }
22645
22646
22647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22648   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22649
22650   arg1 = (Dali::Geometry *)jarg1;
22651   {
22652     try {
22653       delete arg1;
22654     } catch (std::out_of_range& e) {
22655       {
22656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22657       };
22658     } catch (std::exception& e) {
22659       {
22660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22661       };
22662     } catch (...) {
22663       {
22664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22665       };
22666     }
22667   }
22668 }
22669
22670
22671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22672   void * jresult ;
22673   Dali::Geometry *arg1 = 0 ;
22674   Dali::Geometry *result = 0 ;
22675
22676   arg1 = (Dali::Geometry *)jarg1;
22677   if (!arg1) {
22678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22679     return 0;
22680   }
22681   {
22682     try {
22683       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22684     } catch (std::out_of_range& e) {
22685       {
22686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22687       };
22688     } catch (std::exception& e) {
22689       {
22690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22691       };
22692     } catch (...) {
22693       {
22694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22695       };
22696     }
22697   }
22698   jresult = (void *)result;
22699   return jresult;
22700 }
22701
22702
22703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22704   void * jresult ;
22705   Dali::BaseHandle arg1 ;
22706   Dali::BaseHandle *argp1 ;
22707   Dali::Geometry result;
22708
22709   argp1 = (Dali::BaseHandle *)jarg1;
22710   if (!argp1) {
22711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22712     return 0;
22713   }
22714   arg1 = *argp1;
22715   {
22716     try {
22717       result = Dali::Geometry::DownCast(arg1);
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22725       };
22726     } catch (...) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22729       };
22730     }
22731   }
22732   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22733   return jresult;
22734 }
22735
22736
22737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22738   void * jresult ;
22739   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22740   Dali::Geometry *arg2 = 0 ;
22741   Dali::Geometry *result = 0 ;
22742
22743   arg1 = (Dali::Geometry *)jarg1;
22744   arg2 = (Dali::Geometry *)jarg2;
22745   if (!arg2) {
22746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22747     return 0;
22748   }
22749   {
22750     try {
22751       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22752     } catch (std::out_of_range& e) {
22753       {
22754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22755       };
22756     } catch (std::exception& e) {
22757       {
22758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22759       };
22760     } catch (...) {
22761       {
22762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22763       };
22764     }
22765   }
22766   jresult = (void *)result;
22767   return jresult;
22768 }
22769
22770
22771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22772   unsigned long jresult ;
22773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22774   Dali::PropertyBuffer *arg2 = 0 ;
22775   std::size_t result;
22776
22777   arg1 = (Dali::Geometry *)jarg1;
22778   arg2 = (Dali::PropertyBuffer *)jarg2;
22779   if (!arg2) {
22780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22781     return 0;
22782   }
22783   {
22784     try {
22785       result = (arg1)->AddVertexBuffer(*arg2);
22786     } catch (std::out_of_range& e) {
22787       {
22788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22789       };
22790     } catch (std::exception& e) {
22791       {
22792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22793       };
22794     } catch (...) {
22795       {
22796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22797       };
22798     }
22799   }
22800   jresult = (unsigned long)result;
22801   return jresult;
22802 }
22803
22804
22805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22806   unsigned long jresult ;
22807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22808   std::size_t result;
22809
22810   arg1 = (Dali::Geometry *)jarg1;
22811   {
22812     try {
22813       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22814     } catch (std::out_of_range& e) {
22815       {
22816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22817       };
22818     } catch (std::exception& e) {
22819       {
22820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22821       };
22822     } catch (...) {
22823       {
22824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22825       };
22826     }
22827   }
22828   jresult = (unsigned long)result;
22829   return jresult;
22830 }
22831
22832
22833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22834   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22835   std::size_t arg2 ;
22836
22837   arg1 = (Dali::Geometry *)jarg1;
22838   arg2 = (std::size_t)jarg2;
22839   {
22840     try {
22841       (arg1)->RemoveVertexBuffer(arg2);
22842     } catch (std::out_of_range& e) {
22843       {
22844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22845       };
22846     } catch (std::exception& e) {
22847       {
22848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22849       };
22850     } catch (...) {
22851       {
22852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22853       };
22854     }
22855   }
22856 }
22857
22858
22859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22860   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22861   unsigned short *arg2 = (unsigned short *) 0 ;
22862   size_t arg3 ;
22863
22864   arg1 = (Dali::Geometry *)jarg1;
22865   arg2 = jarg2;
22866   arg3 = (size_t)jarg3;
22867   {
22868     try {
22869       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22870     } catch (std::out_of_range& e) {
22871       {
22872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22873       };
22874     } catch (std::exception& e) {
22875       {
22876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22877       };
22878     } catch (...) {
22879       {
22880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22881       };
22882     }
22883   }
22884
22885
22886 }
22887
22888
22889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22890   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22891   Dali::Geometry::Type arg2 ;
22892
22893   arg1 = (Dali::Geometry *)jarg1;
22894   arg2 = (Dali::Geometry::Type)jarg2;
22895   {
22896     try {
22897       (arg1)->SetType(arg2);
22898     } catch (std::out_of_range& e) {
22899       {
22900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22901       };
22902     } catch (std::exception& e) {
22903       {
22904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22905       };
22906     } catch (...) {
22907       {
22908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22909       };
22910     }
22911   }
22912 }
22913
22914
22915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22916   int jresult ;
22917   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22918   Dali::Geometry::Type result;
22919
22920   arg1 = (Dali::Geometry *)jarg1;
22921   {
22922     try {
22923       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22924     } catch (std::out_of_range& e) {
22925       {
22926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22927       };
22928     } catch (std::exception& e) {
22929       {
22930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22931       };
22932     } catch (...) {
22933       {
22934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22935       };
22936     }
22937   }
22938   jresult = (int)result;
22939   return jresult;
22940 }
22941
22942
22943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22944   void * jresult ;
22945   Dali::Shader::Hint *result = 0 ;
22946
22947   {
22948     try {
22949       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22950     } catch (std::out_of_range& e) {
22951       {
22952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22953       };
22954     } catch (std::exception& e) {
22955       {
22956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22957       };
22958     } catch (...) {
22959       {
22960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22961       };
22962     }
22963   }
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22970   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22971
22972   arg1 = (Dali::Shader::Hint *)jarg1;
22973   {
22974     try {
22975       delete arg1;
22976     } catch (std::out_of_range& e) {
22977       {
22978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22979       };
22980     } catch (std::exception& e) {
22981       {
22982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22983       };
22984     } catch (...) {
22985       {
22986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22987       };
22988     }
22989   }
22990 }
22991
22992
22993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22994   int jresult ;
22995   int result;
22996
22997   result = (int)Dali::Shader::Property::PROGRAM;
22998   jresult = (int)result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23004   void * jresult ;
23005   Dali::Shader::Property *result = 0 ;
23006
23007   {
23008     try {
23009       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23010     } catch (std::out_of_range& e) {
23011       {
23012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23013       };
23014     } catch (std::exception& e) {
23015       {
23016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23017       };
23018     } catch (...) {
23019       {
23020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23021       };
23022     }
23023   }
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23030   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23031
23032   arg1 = (Dali::Shader::Property *)jarg1;
23033   {
23034     try {
23035       delete arg1;
23036     } catch (std::out_of_range& e) {
23037       {
23038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23039       };
23040     } catch (std::exception& e) {
23041       {
23042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23043       };
23044     } catch (...) {
23045       {
23046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23047       };
23048     }
23049   }
23050 }
23051
23052
23053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23054   void * jresult ;
23055   std::string *arg1 = 0 ;
23056   std::string *arg2 = 0 ;
23057   Dali::Shader::Hint::Value arg3 ;
23058   Dali::Shader result;
23059
23060   if (!jarg1) {
23061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23062     return 0;
23063   }
23064   std::string arg1_str(jarg1);
23065   arg1 = &arg1_str;
23066   if (!jarg2) {
23067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23068     return 0;
23069   }
23070   std::string arg2_str(jarg2);
23071   arg2 = &arg2_str;
23072   arg3 = (Dali::Shader::Hint::Value)jarg3;
23073   {
23074     try {
23075       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23076     } catch (std::out_of_range& e) {
23077       {
23078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23079       };
23080     } catch (std::exception& e) {
23081       {
23082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23083       };
23084     } catch (...) {
23085       {
23086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23087       };
23088     }
23089   }
23090   jresult = new Dali::Shader((const Dali::Shader &)result);
23091
23092   //argout typemap for const std::string&
23093
23094
23095   //argout typemap for const std::string&
23096
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23102   void * jresult ;
23103   std::string *arg1 = 0 ;
23104   std::string *arg2 = 0 ;
23105   Dali::Shader result;
23106
23107   if (!jarg1) {
23108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23109     return 0;
23110   }
23111   std::string arg1_str(jarg1);
23112   arg1 = &arg1_str;
23113   if (!jarg2) {
23114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23115     return 0;
23116   }
23117   std::string arg2_str(jarg2);
23118   arg2 = &arg2_str;
23119   {
23120     try {
23121       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23122     } catch (std::out_of_range& e) {
23123       {
23124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23125       };
23126     } catch (std::exception& e) {
23127       {
23128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23129       };
23130     } catch (...) {
23131       {
23132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23133       };
23134     }
23135   }
23136   jresult = new Dali::Shader((const Dali::Shader &)result);
23137
23138   //argout typemap for const std::string&
23139
23140
23141   //argout typemap for const std::string&
23142
23143   return jresult;
23144 }
23145
23146
23147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23148   void * jresult ;
23149   Dali::Shader *result = 0 ;
23150
23151   {
23152     try {
23153       result = (Dali::Shader *)new Dali::Shader();
23154     } catch (std::out_of_range& e) {
23155       {
23156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23157       };
23158     } catch (std::exception& e) {
23159       {
23160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23161       };
23162     } catch (...) {
23163       {
23164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23165       };
23166     }
23167   }
23168   jresult = (void *)result;
23169   return jresult;
23170 }
23171
23172
23173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23174   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23175
23176   arg1 = (Dali::Shader *)jarg1;
23177   {
23178     try {
23179       delete arg1;
23180     } catch (std::out_of_range& e) {
23181       {
23182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23183       };
23184     } catch (std::exception& e) {
23185       {
23186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23187       };
23188     } catch (...) {
23189       {
23190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23191       };
23192     }
23193   }
23194 }
23195
23196
23197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23198   void * jresult ;
23199   Dali::Shader *arg1 = 0 ;
23200   Dali::Shader *result = 0 ;
23201
23202   arg1 = (Dali::Shader *)jarg1;
23203   if (!arg1) {
23204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23205     return 0;
23206   }
23207   {
23208     try {
23209       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23210     } catch (std::out_of_range& e) {
23211       {
23212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23213       };
23214     } catch (std::exception& e) {
23215       {
23216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23217       };
23218     } catch (...) {
23219       {
23220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23221       };
23222     }
23223   }
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23230   void * jresult ;
23231   Dali::BaseHandle arg1 ;
23232   Dali::BaseHandle *argp1 ;
23233   Dali::Shader result;
23234
23235   argp1 = (Dali::BaseHandle *)jarg1;
23236   if (!argp1) {
23237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23238     return 0;
23239   }
23240   arg1 = *argp1;
23241   {
23242     try {
23243       result = Dali::Shader::DownCast(arg1);
23244     } catch (std::out_of_range& e) {
23245       {
23246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23247       };
23248     } catch (std::exception& e) {
23249       {
23250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23251       };
23252     } catch (...) {
23253       {
23254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23255       };
23256     }
23257   }
23258   jresult = new Dali::Shader((const Dali::Shader &)result);
23259   return jresult;
23260 }
23261
23262
23263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23264   void * jresult ;
23265   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23266   Dali::Shader *arg2 = 0 ;
23267   Dali::Shader *result = 0 ;
23268
23269   arg1 = (Dali::Shader *)jarg1;
23270   arg2 = (Dali::Shader *)jarg2;
23271   if (!arg2) {
23272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23273     return 0;
23274   }
23275   {
23276     try {
23277       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23278     } catch (std::out_of_range& e) {
23279       {
23280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23281       };
23282     } catch (std::exception& e) {
23283       {
23284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23285       };
23286     } catch (...) {
23287       {
23288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23289       };
23290     }
23291   }
23292   jresult = (void *)result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23298   int jresult ;
23299   int result;
23300
23301   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23302   jresult = (int)result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23308   int jresult ;
23309   int result;
23310
23311   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23312   jresult = (int)result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23318   int jresult ;
23319   int result;
23320
23321   result = (int)Dali::Renderer::Property::BLEND_MODE;
23322   jresult = (int)result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23328   int jresult ;
23329   int result;
23330
23331   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23332   jresult = (int)result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23338   int jresult ;
23339   int result;
23340
23341   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23342   jresult = (int)result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23348   int jresult ;
23349   int result;
23350
23351   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23352   jresult = (int)result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23358   int jresult ;
23359   int result;
23360
23361   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23362   jresult = (int)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23368   int jresult ;
23369   int result;
23370
23371   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23372   jresult = (int)result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23378   int jresult ;
23379   int result;
23380
23381   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23382   jresult = (int)result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23388   int jresult ;
23389   int result;
23390
23391   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23398   int jresult ;
23399   int result;
23400
23401   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23402   jresult = (int)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23408   int jresult ;
23409   int result;
23410
23411   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23418   int jresult ;
23419   int result;
23420
23421   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23422   jresult = (int)result;
23423   return jresult;
23424 }
23425
23426
23427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23428   int jresult ;
23429   int result;
23430
23431   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23432   jresult = (int)result;
23433   return jresult;
23434 }
23435
23436
23437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23438   int jresult ;
23439   int result;
23440
23441   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23442   jresult = (int)result;
23443   return jresult;
23444 }
23445
23446
23447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23448   int jresult ;
23449   int result;
23450
23451   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23452   jresult = (int)result;
23453   return jresult;
23454 }
23455
23456
23457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23458   int jresult ;
23459   int result;
23460
23461   result = (int)Dali::Renderer::Property::RENDER_MODE;
23462   jresult = (int)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23468   int jresult ;
23469   int result;
23470
23471   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23472   jresult = (int)result;
23473   return jresult;
23474 }
23475
23476
23477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23478   int jresult ;
23479   int result;
23480
23481   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23482   jresult = (int)result;
23483   return jresult;
23484 }
23485
23486
23487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23488   int jresult ;
23489   int result;
23490
23491   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23492   jresult = (int)result;
23493   return jresult;
23494 }
23495
23496
23497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23498   int jresult ;
23499   int result;
23500
23501   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23502   jresult = (int)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23538   void * jresult ;
23539   Dali::Renderer::Property *result = 0 ;
23540
23541   {
23542     try {
23543       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23544     } catch (std::out_of_range& e) {
23545       {
23546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23547       };
23548     } catch (std::exception& e) {
23549       {
23550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23555       };
23556     }
23557   }
23558   jresult = (void *)result;
23559   return jresult;
23560 }
23561
23562
23563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23564   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23565
23566   arg1 = (Dali::Renderer::Property *)jarg1;
23567   {
23568     try {
23569       delete arg1;
23570     } catch (std::out_of_range& e) {
23571       {
23572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23573       };
23574     } catch (std::exception& e) {
23575       {
23576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23577       };
23578     } catch (...) {
23579       {
23580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23581       };
23582     }
23583   }
23584 }
23585
23586
23587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23588   void * jresult ;
23589   Dali::Geometry *arg1 = 0 ;
23590   Dali::Shader *arg2 = 0 ;
23591   Dali::Renderer result;
23592
23593   arg1 = (Dali::Geometry *)jarg1;
23594   if (!arg1) {
23595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23596     return 0;
23597   }
23598   arg2 = (Dali::Shader *)jarg2;
23599   if (!arg2) {
23600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23601     return 0;
23602   }
23603   {
23604     try {
23605       result = Dali::Renderer::New(*arg1,*arg2);
23606     } catch (std::out_of_range& e) {
23607       {
23608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23609       };
23610     } catch (std::exception& e) {
23611       {
23612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23613       };
23614     } catch (...) {
23615       {
23616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23617       };
23618     }
23619   }
23620   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23621   return jresult;
23622 }
23623
23624
23625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23626   void * jresult ;
23627   Dali::Renderer *result = 0 ;
23628
23629   {
23630     try {
23631       result = (Dali::Renderer *)new Dali::Renderer();
23632     } catch (std::out_of_range& e) {
23633       {
23634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23635       };
23636     } catch (std::exception& e) {
23637       {
23638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (...) {
23641       {
23642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23643       };
23644     }
23645   }
23646   jresult = (void *)result;
23647   return jresult;
23648 }
23649
23650
23651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23652   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23653
23654   arg1 = (Dali::Renderer *)jarg1;
23655   {
23656     try {
23657       delete arg1;
23658     } catch (std::out_of_range& e) {
23659       {
23660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23661       };
23662     } catch (std::exception& e) {
23663       {
23664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23665       };
23666     } catch (...) {
23667       {
23668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23669       };
23670     }
23671   }
23672 }
23673
23674
23675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23676   void * jresult ;
23677   Dali::Renderer *arg1 = 0 ;
23678   Dali::Renderer *result = 0 ;
23679
23680   arg1 = (Dali::Renderer *)jarg1;
23681   if (!arg1) {
23682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23683     return 0;
23684   }
23685   {
23686     try {
23687       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23688     } catch (std::out_of_range& e) {
23689       {
23690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23691       };
23692     } catch (std::exception& e) {
23693       {
23694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23695       };
23696     } catch (...) {
23697       {
23698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23699       };
23700     }
23701   }
23702   jresult = (void *)result;
23703   return jresult;
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23708   void * jresult ;
23709   Dali::BaseHandle arg1 ;
23710   Dali::BaseHandle *argp1 ;
23711   Dali::Renderer result;
23712
23713   argp1 = (Dali::BaseHandle *)jarg1;
23714   if (!argp1) {
23715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23716     return 0;
23717   }
23718   arg1 = *argp1;
23719   {
23720     try {
23721       result = Dali::Renderer::DownCast(arg1);
23722     } catch (std::out_of_range& e) {
23723       {
23724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23725       };
23726     } catch (std::exception& e) {
23727       {
23728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23729       };
23730     } catch (...) {
23731       {
23732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23733       };
23734     }
23735   }
23736   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23737   return jresult;
23738 }
23739
23740
23741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23742   void * jresult ;
23743   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23744   Dali::Renderer *arg2 = 0 ;
23745   Dali::Renderer *result = 0 ;
23746
23747   arg1 = (Dali::Renderer *)jarg1;
23748   arg2 = (Dali::Renderer *)jarg2;
23749   if (!arg2) {
23750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23751     return 0;
23752   }
23753   {
23754     try {
23755       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23756     } catch (std::out_of_range& e) {
23757       {
23758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23759       };
23760     } catch (std::exception& e) {
23761       {
23762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23763       };
23764     } catch (...) {
23765       {
23766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23767       };
23768     }
23769   }
23770   jresult = (void *)result;
23771   return jresult;
23772 }
23773
23774
23775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23776   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23777   Dali::Geometry *arg2 = 0 ;
23778
23779   arg1 = (Dali::Renderer *)jarg1;
23780   arg2 = (Dali::Geometry *)jarg2;
23781   if (!arg2) {
23782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23783     return ;
23784   }
23785   {
23786     try {
23787       (arg1)->SetGeometry(*arg2);
23788     } catch (std::out_of_range& e) {
23789       {
23790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23791       };
23792     } catch (std::exception& e) {
23793       {
23794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23795       };
23796     } catch (...) {
23797       {
23798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23799       };
23800     }
23801   }
23802 }
23803
23804
23805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23806   void * jresult ;
23807   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23808   Dali::Geometry result;
23809
23810   arg1 = (Dali::Renderer *)jarg1;
23811   {
23812     try {
23813       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23814     } catch (std::out_of_range& e) {
23815       {
23816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (std::exception& e) {
23819       {
23820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23834   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23835   int arg2 ;
23836   int arg3 ;
23837
23838   arg1 = (Dali::Renderer *)jarg1;
23839   arg2 = (int)jarg2;
23840   arg3 = (int)jarg3;
23841   {
23842     try {
23843       (arg1)->SetIndexRange(arg2,arg3);
23844     } catch (std::out_of_range& e) {
23845       {
23846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23847       };
23848     } catch (std::exception& e) {
23849       {
23850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23851       };
23852     } catch (...) {
23853       {
23854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23855       };
23856     }
23857   }
23858 }
23859
23860
23861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23862   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23863   Dali::TextureSet *arg2 = 0 ;
23864
23865   arg1 = (Dali::Renderer *)jarg1;
23866   arg2 = (Dali::TextureSet *)jarg2;
23867   if (!arg2) {
23868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23869     return ;
23870   }
23871   {
23872     try {
23873       (arg1)->SetTextures(*arg2);
23874     } catch (std::out_of_range& e) {
23875       {
23876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23877       };
23878     } catch (std::exception& e) {
23879       {
23880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23881       };
23882     } catch (...) {
23883       {
23884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23885       };
23886     }
23887   }
23888 }
23889
23890
23891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23892   void * jresult ;
23893   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23894   Dali::TextureSet result;
23895
23896   arg1 = (Dali::Renderer *)jarg1;
23897   {
23898     try {
23899       result = ((Dali::Renderer const *)arg1)->GetTextures();
23900     } catch (std::out_of_range& e) {
23901       {
23902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (std::exception& e) {
23905       {
23906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23915   return jresult;
23916 }
23917
23918
23919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23920   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23921   Dali::Shader *arg2 = 0 ;
23922
23923   arg1 = (Dali::Renderer *)jarg1;
23924   arg2 = (Dali::Shader *)jarg2;
23925   if (!arg2) {
23926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23927     return ;
23928   }
23929   {
23930     try {
23931       (arg1)->SetShader(*arg2);
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (...) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23943       };
23944     }
23945   }
23946 }
23947
23948
23949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23950   void * jresult ;
23951   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23952   Dali::Shader result;
23953
23954   arg1 = (Dali::Renderer *)jarg1;
23955   {
23956     try {
23957       result = ((Dali::Renderer const *)arg1)->GetShader();
23958     } catch (std::out_of_range& e) {
23959       {
23960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23961       };
23962     } catch (std::exception& e) {
23963       {
23964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23965       };
23966     } catch (...) {
23967       {
23968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23969       };
23970     }
23971   }
23972   jresult = new Dali::Shader((const Dali::Shader &)result);
23973   return jresult;
23974 }
23975
23976
23977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23978   void * jresult ;
23979   Dali::FrameBuffer::Attachment *result = 0 ;
23980
23981   {
23982     try {
23983       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (...) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23995       };
23996     }
23997   }
23998   jresult = (void *)result;
23999   return jresult;
24000 }
24001
24002
24003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24004   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24005
24006   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24007   {
24008     try {
24009       delete arg1;
24010     } catch (std::out_of_range& e) {
24011       {
24012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24013       };
24014     } catch (std::exception& e) {
24015       {
24016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24017       };
24018     } catch (...) {
24019       {
24020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24021       };
24022     }
24023   }
24024 }
24025
24026
24027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24028   void * jresult ;
24029   unsigned int arg1 ;
24030   unsigned int arg2 ;
24031   unsigned int arg3 ;
24032   Dali::FrameBuffer result;
24033
24034   arg1 = (unsigned int)jarg1;
24035   arg2 = (unsigned int)jarg2;
24036   arg3 = (unsigned int)jarg3;
24037   {
24038     try {
24039       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (...) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24051       };
24052     }
24053   }
24054   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24055   return jresult;
24056 }
24057
24058
24059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24060   void * jresult ;
24061   Dali::FrameBuffer *result = 0 ;
24062
24063   {
24064     try {
24065       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24066     } catch (std::out_of_range& e) {
24067       {
24068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (std::exception& e) {
24071       {
24072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24073       };
24074     } catch (...) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24077       };
24078     }
24079   }
24080   jresult = (void *)result;
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24086   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24087
24088   arg1 = (Dali::FrameBuffer *)jarg1;
24089   {
24090     try {
24091       delete arg1;
24092     } catch (std::out_of_range& e) {
24093       {
24094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24095       };
24096     } catch (std::exception& e) {
24097       {
24098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24099       };
24100     } catch (...) {
24101       {
24102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24103       };
24104     }
24105   }
24106 }
24107
24108
24109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24110   void * jresult ;
24111   Dali::FrameBuffer *arg1 = 0 ;
24112   Dali::FrameBuffer *result = 0 ;
24113
24114   arg1 = (Dali::FrameBuffer *)jarg1;
24115   if (!arg1) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136   jresult = (void *)result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24142   void * jresult ;
24143   Dali::BaseHandle arg1 ;
24144   Dali::BaseHandle *argp1 ;
24145   Dali::FrameBuffer result;
24146
24147   argp1 = (Dali::BaseHandle *)jarg1;
24148   if (!argp1) {
24149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24150     return 0;
24151   }
24152   arg1 = *argp1;
24153   {
24154     try {
24155       result = Dali::FrameBuffer::DownCast(arg1);
24156     } catch (std::out_of_range& e) {
24157       {
24158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24159       };
24160     } catch (std::exception& e) {
24161       {
24162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24163       };
24164     } catch (...) {
24165       {
24166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24167       };
24168     }
24169   }
24170   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24176   void * jresult ;
24177   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24178   Dali::FrameBuffer *arg2 = 0 ;
24179   Dali::FrameBuffer *result = 0 ;
24180
24181   arg1 = (Dali::FrameBuffer *)jarg1;
24182   arg2 = (Dali::FrameBuffer *)jarg2;
24183   if (!arg2) {
24184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24185     return 0;
24186   }
24187   {
24188     try {
24189       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24190     } catch (std::out_of_range& e) {
24191       {
24192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24193       };
24194     } catch (std::exception& e) {
24195       {
24196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24197       };
24198     } catch (...) {
24199       {
24200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24201       };
24202     }
24203   }
24204   jresult = (void *)result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24210   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24211   Dali::Texture *arg2 = 0 ;
24212
24213   arg1 = (Dali::FrameBuffer *)jarg1;
24214   arg2 = (Dali::Texture *)jarg2;
24215   if (!arg2) {
24216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24217     return ;
24218   }
24219   {
24220     try {
24221       (arg1)->AttachColorTexture(*arg2);
24222     } catch (std::out_of_range& e) {
24223       {
24224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24225       };
24226     } catch (std::exception& e) {
24227       {
24228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24229       };
24230     } catch (...) {
24231       {
24232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24233       };
24234     }
24235   }
24236 }
24237
24238
24239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24240   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24241   Dali::Texture *arg2 = 0 ;
24242   unsigned int arg3 ;
24243   unsigned int arg4 ;
24244
24245   arg1 = (Dali::FrameBuffer *)jarg1;
24246   arg2 = (Dali::Texture *)jarg2;
24247   if (!arg2) {
24248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24249     return ;
24250   }
24251   arg3 = (unsigned int)jarg3;
24252   arg4 = (unsigned int)jarg4;
24253   {
24254     try {
24255       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24256     } catch (std::out_of_range& e) {
24257       {
24258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24259       };
24260     } catch (std::exception& e) {
24261       {
24262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24263       };
24264     } catch (...) {
24265       {
24266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24267       };
24268     }
24269   }
24270 }
24271
24272
24273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24274   void * jresult ;
24275   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24276   Dali::Texture result;
24277
24278   arg1 = (Dali::FrameBuffer *)jarg1;
24279   {
24280     try {
24281       result = (arg1)->GetColorTexture();
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24293       };
24294     }
24295   }
24296   jresult = new Dali::Texture((const Dali::Texture &)result);
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24302   void * jresult ;
24303   Dali::RenderTaskList *result = 0 ;
24304
24305   {
24306     try {
24307       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24308     } catch (std::out_of_range& e) {
24309       {
24310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24311       };
24312     } catch (std::exception& e) {
24313       {
24314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24315       };
24316     } catch (...) {
24317       {
24318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24319       };
24320     }
24321   }
24322   jresult = (void *)result;
24323   return jresult;
24324 }
24325
24326
24327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24328   void * jresult ;
24329   Dali::BaseHandle arg1 ;
24330   Dali::BaseHandle *argp1 ;
24331   Dali::RenderTaskList result;
24332
24333   argp1 = (Dali::BaseHandle *)jarg1;
24334   if (!argp1) {
24335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24336     return 0;
24337   }
24338   arg1 = *argp1;
24339   {
24340     try {
24341       result = Dali::RenderTaskList::DownCast(arg1);
24342     } catch (std::out_of_range& e) {
24343       {
24344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24345       };
24346     } catch (std::exception& e) {
24347       {
24348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24349       };
24350     } catch (...) {
24351       {
24352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24353       };
24354     }
24355   }
24356   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24362   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24363
24364   arg1 = (Dali::RenderTaskList *)jarg1;
24365   {
24366     try {
24367       delete arg1;
24368     } catch (std::out_of_range& e) {
24369       {
24370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24371       };
24372     } catch (std::exception& e) {
24373       {
24374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24375       };
24376     } catch (...) {
24377       {
24378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24379       };
24380     }
24381   }
24382 }
24383
24384
24385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24386   void * jresult ;
24387   Dali::RenderTaskList *arg1 = 0 ;
24388   Dali::RenderTaskList *result = 0 ;
24389
24390   arg1 = (Dali::RenderTaskList *)jarg1;
24391   if (!arg1) {
24392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24393     return 0;
24394   }
24395   {
24396     try {
24397       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24398     } catch (std::out_of_range& e) {
24399       {
24400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24401       };
24402     } catch (std::exception& e) {
24403       {
24404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24405       };
24406     } catch (...) {
24407       {
24408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24409       };
24410     }
24411   }
24412   jresult = (void *)result;
24413   return jresult;
24414 }
24415
24416
24417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24418   void * jresult ;
24419   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24420   Dali::RenderTaskList *arg2 = 0 ;
24421   Dali::RenderTaskList *result = 0 ;
24422
24423   arg1 = (Dali::RenderTaskList *)jarg1;
24424   arg2 = (Dali::RenderTaskList *)jarg2;
24425   if (!arg2) {
24426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24427     return 0;
24428   }
24429   {
24430     try {
24431       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24432     } catch (std::out_of_range& e) {
24433       {
24434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24435       };
24436     } catch (std::exception& e) {
24437       {
24438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24439       };
24440     } catch (...) {
24441       {
24442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24443       };
24444     }
24445   }
24446   jresult = (void *)result;
24447   return jresult;
24448 }
24449
24450
24451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24452   void * jresult ;
24453   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24454   Dali::RenderTask result;
24455
24456   arg1 = (Dali::RenderTaskList *)jarg1;
24457   {
24458     try {
24459       result = (arg1)->CreateTask();
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (...) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24471       };
24472     }
24473   }
24474   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24475   return jresult;
24476 }
24477
24478
24479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24480   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24481   Dali::RenderTask arg2 ;
24482   Dali::RenderTask *argp2 ;
24483
24484   arg1 = (Dali::RenderTaskList *)jarg1;
24485   argp2 = (Dali::RenderTask *)jarg2;
24486   if (!argp2) {
24487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24488     return ;
24489   }
24490   arg2 = *argp2;
24491   {
24492     try {
24493       (arg1)->RemoveTask(arg2);
24494     } catch (std::out_of_range& e) {
24495       {
24496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24497       };
24498     } catch (std::exception& e) {
24499       {
24500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24501       };
24502     } catch (...) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24505       };
24506     }
24507   }
24508 }
24509
24510
24511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24512   unsigned int jresult ;
24513   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24514   unsigned int result;
24515
24516   arg1 = (Dali::RenderTaskList *)jarg1;
24517   {
24518     try {
24519       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24520     } catch (std::out_of_range& e) {
24521       {
24522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (std::exception& e) {
24525       {
24526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534   jresult = result;
24535   return jresult;
24536 }
24537
24538
24539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24540   void * jresult ;
24541   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24542   unsigned int arg2 ;
24543   Dali::RenderTask result;
24544
24545   arg1 = (Dali::RenderTaskList *)jarg1;
24546   arg2 = (unsigned int)jarg2;
24547   {
24548     try {
24549       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24550     } catch (std::out_of_range& e) {
24551       {
24552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24553       };
24554     } catch (std::exception& e) {
24555       {
24556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24557       };
24558     } catch (...) {
24559       {
24560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24561       };
24562     }
24563   }
24564   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24565   return jresult;
24566 }
24567
24568
24569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24570   int jresult ;
24571   int result;
24572
24573   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24574   jresult = (int)result;
24575   return jresult;
24576 }
24577
24578
24579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24580   int jresult ;
24581   int result;
24582
24583   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24584   jresult = (int)result;
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24590   int jresult ;
24591   int result;
24592
24593   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24594   jresult = (int)result;
24595   return jresult;
24596 }
24597
24598
24599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24600   int jresult ;
24601   int result;
24602
24603   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24604   jresult = (int)result;
24605   return jresult;
24606 }
24607
24608
24609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24610   void * jresult ;
24611   Dali::RenderTask::Property *result = 0 ;
24612
24613   {
24614     try {
24615       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24616     } catch (std::out_of_range& e) {
24617       {
24618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24619       };
24620     } catch (std::exception& e) {
24621       {
24622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24623       };
24624     } catch (...) {
24625       {
24626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24627       };
24628     }
24629   }
24630   jresult = (void *)result;
24631   return jresult;
24632 }
24633
24634
24635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24636   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24637
24638   arg1 = (Dali::RenderTask::Property *)jarg1;
24639   {
24640     try {
24641       delete arg1;
24642     } catch (std::out_of_range& e) {
24643       {
24644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24645       };
24646     } catch (std::exception& e) {
24647       {
24648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24649       };
24650     } catch (...) {
24651       {
24652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24653       };
24654     }
24655   }
24656 }
24657
24658
24659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24660   void * jresult ;
24661   bool (*result)(Dali::Vector2 &) = 0 ;
24662
24663   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24664   jresult = (void *)result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24670   void * jresult ;
24671   bool (*result)(Dali::Vector2 &) = 0 ;
24672
24673   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24674   jresult = (void *)result;
24675   return jresult;
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24680   unsigned int jresult ;
24681   bool result;
24682
24683   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24684   jresult = result;
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24690   unsigned int jresult ;
24691   bool result;
24692
24693   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24694   jresult = result;
24695   return jresult;
24696 }
24697
24698
24699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24700   void * jresult ;
24701   Dali::Vector4 *result = 0 ;
24702
24703   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24704   jresult = (void *)result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24710   unsigned int jresult ;
24711   bool result;
24712
24713   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24714   jresult = result;
24715   return jresult;
24716 }
24717
24718
24719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24720   unsigned int jresult ;
24721   bool result;
24722
24723   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24724   jresult = result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24730   unsigned int jresult ;
24731   unsigned int result;
24732
24733   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24734   jresult = result;
24735   return jresult;
24736 }
24737
24738
24739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24740   void * jresult ;
24741   Dali::RenderTask *result = 0 ;
24742
24743   {
24744     try {
24745       result = (Dali::RenderTask *)new Dali::RenderTask();
24746     } catch (std::out_of_range& e) {
24747       {
24748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24749       };
24750     } catch (std::exception& e) {
24751       {
24752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24753       };
24754     } catch (...) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24757       };
24758     }
24759   }
24760   jresult = (void *)result;
24761   return jresult;
24762 }
24763
24764
24765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24766   void * jresult ;
24767   Dali::BaseHandle arg1 ;
24768   Dali::BaseHandle *argp1 ;
24769   Dali::RenderTask result;
24770
24771   argp1 = (Dali::BaseHandle *)jarg1;
24772   if (!argp1) {
24773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24774     return 0;
24775   }
24776   arg1 = *argp1;
24777   {
24778     try {
24779       result = Dali::RenderTask::DownCast(arg1);
24780     } catch (std::out_of_range& e) {
24781       {
24782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24783       };
24784     } catch (std::exception& e) {
24785       {
24786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24787       };
24788     } catch (...) {
24789       {
24790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24791       };
24792     }
24793   }
24794   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24795   return jresult;
24796 }
24797
24798
24799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24800   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24801
24802   arg1 = (Dali::RenderTask *)jarg1;
24803   {
24804     try {
24805       delete arg1;
24806     } catch (std::out_of_range& e) {
24807       {
24808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24809       };
24810     } catch (std::exception& e) {
24811       {
24812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (...) {
24815       {
24816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24817       };
24818     }
24819   }
24820 }
24821
24822
24823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24824   void * jresult ;
24825   Dali::RenderTask *arg1 = 0 ;
24826   Dali::RenderTask *result = 0 ;
24827
24828   arg1 = (Dali::RenderTask *)jarg1;
24829   if (!arg1) {
24830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24831     return 0;
24832   }
24833   {
24834     try {
24835       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24836     } catch (std::out_of_range& e) {
24837       {
24838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (std::exception& e) {
24841       {
24842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (...) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24847       };
24848     }
24849   }
24850   jresult = (void *)result;
24851   return jresult;
24852 }
24853
24854
24855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24856   void * jresult ;
24857   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24858   Dali::RenderTask *arg2 = 0 ;
24859   Dali::RenderTask *result = 0 ;
24860
24861   arg1 = (Dali::RenderTask *)jarg1;
24862   arg2 = (Dali::RenderTask *)jarg2;
24863   if (!arg2) {
24864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24865     return 0;
24866   }
24867   {
24868     try {
24869       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24877       };
24878     } catch (...) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24881       };
24882     }
24883   }
24884   jresult = (void *)result;
24885   return jresult;
24886 }
24887
24888
24889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24890   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24891   Dali::Actor arg2 ;
24892   Dali::Actor *argp2 ;
24893
24894   arg1 = (Dali::RenderTask *)jarg1;
24895   argp2 = (Dali::Actor *)jarg2;
24896   if (!argp2) {
24897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24898     return ;
24899   }
24900   arg2 = *argp2;
24901   {
24902     try {
24903       (arg1)->SetSourceActor(arg2);
24904     } catch (std::out_of_range& e) {
24905       {
24906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24907       };
24908     } catch (std::exception& e) {
24909       {
24910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24911       };
24912     } catch (...) {
24913       {
24914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24915       };
24916     }
24917   }
24918 }
24919
24920
24921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24922   void * jresult ;
24923   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24924   Dali::Actor result;
24925
24926   arg1 = (Dali::RenderTask *)jarg1;
24927   {
24928     try {
24929       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24930     } catch (std::out_of_range& e) {
24931       {
24932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24933       };
24934     } catch (std::exception& e) {
24935       {
24936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24937       };
24938     } catch (...) {
24939       {
24940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24941       };
24942     }
24943   }
24944   jresult = new Dali::Actor((const Dali::Actor &)result);
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24951   bool arg2 ;
24952
24953   arg1 = (Dali::RenderTask *)jarg1;
24954   arg2 = jarg2 ? true : false;
24955   {
24956     try {
24957       (arg1)->SetExclusive(arg2);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (...) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24969       };
24970     }
24971   }
24972 }
24973
24974
24975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24976   unsigned int jresult ;
24977   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24978   bool result;
24979
24980   arg1 = (Dali::RenderTask *)jarg1;
24981   {
24982     try {
24983       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24984     } catch (std::out_of_range& e) {
24985       {
24986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24987       };
24988     } catch (std::exception& e) {
24989       {
24990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24991       };
24992     } catch (...) {
24993       {
24994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24995       };
24996     }
24997   }
24998   jresult = result;
24999   return jresult;
25000 }
25001
25002
25003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25004   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25005   bool arg2 ;
25006
25007   arg1 = (Dali::RenderTask *)jarg1;
25008   arg2 = jarg2 ? true : false;
25009   {
25010     try {
25011       (arg1)->SetInputEnabled(arg2);
25012     } catch (std::out_of_range& e) {
25013       {
25014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25015       };
25016     } catch (std::exception& e) {
25017       {
25018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25019       };
25020     } catch (...) {
25021       {
25022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25023       };
25024     }
25025   }
25026 }
25027
25028
25029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25030   unsigned int jresult ;
25031   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25032   bool result;
25033
25034   arg1 = (Dali::RenderTask *)jarg1;
25035   {
25036     try {
25037       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25038     } catch (std::out_of_range& e) {
25039       {
25040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25041       };
25042     } catch (std::exception& e) {
25043       {
25044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25049       };
25050     }
25051   }
25052   jresult = result;
25053   return jresult;
25054 }
25055
25056
25057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25058   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25059   Dali::CameraActor arg2 ;
25060   Dali::CameraActor *argp2 ;
25061
25062   arg1 = (Dali::RenderTask *)jarg1;
25063   argp2 = (Dali::CameraActor *)jarg2;
25064   if (!argp2) {
25065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25066     return ;
25067   }
25068   arg2 = *argp2;
25069   {
25070     try {
25071       (arg1)->SetCameraActor(arg2);
25072     } catch (std::out_of_range& e) {
25073       {
25074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25075       };
25076     } catch (std::exception& e) {
25077       {
25078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25079       };
25080     } catch (...) {
25081       {
25082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25083       };
25084     }
25085   }
25086 }
25087
25088
25089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25090   void * jresult ;
25091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25092   Dali::CameraActor result;
25093
25094   arg1 = (Dali::RenderTask *)jarg1;
25095   {
25096     try {
25097       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25098     } catch (std::out_of_range& e) {
25099       {
25100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25101       };
25102     } catch (std::exception& e) {
25103       {
25104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25105       };
25106     } catch (...) {
25107       {
25108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25109       };
25110     }
25111   }
25112   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25113   return jresult;
25114 }
25115
25116
25117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25118   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25119   Dali::FrameBufferImage arg2 ;
25120   Dali::FrameBufferImage *argp2 ;
25121
25122   arg1 = (Dali::RenderTask *)jarg1;
25123   argp2 = (Dali::FrameBufferImage *)jarg2;
25124   if (!argp2) {
25125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25126     return ;
25127   }
25128   arg2 = *argp2;
25129   {
25130     try {
25131       (arg1)->SetTargetFrameBuffer(arg2);
25132     } catch (std::out_of_range& e) {
25133       {
25134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25135       };
25136     } catch (std::exception& e) {
25137       {
25138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25139       };
25140     } catch (...) {
25141       {
25142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25143       };
25144     }
25145   }
25146 }
25147
25148
25149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25150   void * jresult ;
25151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25152   Dali::FrameBufferImage result;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   {
25156     try {
25157       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25158     } catch (std::out_of_range& e) {
25159       {
25160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (std::exception& e) {
25163       {
25164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25173   return jresult;
25174 }
25175
25176
25177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25178   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25179   Dali::FrameBuffer arg2 ;
25180   Dali::FrameBuffer *argp2 ;
25181
25182   arg1 = (Dali::RenderTask *)jarg1;
25183   argp2 = (Dali::FrameBuffer *)jarg2;
25184   if (!argp2) {
25185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25186     return ;
25187   }
25188   arg2 = *argp2;
25189   {
25190     try {
25191       (arg1)->SetFrameBuffer(arg2);
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25199       };
25200     } catch (...) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25203       };
25204     }
25205   }
25206 }
25207
25208
25209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25210   void * jresult ;
25211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25212   Dali::FrameBuffer result;
25213
25214   arg1 = (Dali::RenderTask *)jarg1;
25215   {
25216     try {
25217       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25218     } catch (std::out_of_range& e) {
25219       {
25220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25221       };
25222     } catch (std::exception& e) {
25223       {
25224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25225       };
25226     } catch (...) {
25227       {
25228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25229       };
25230     }
25231   }
25232   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25233   return jresult;
25234 }
25235
25236
25237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25239   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25240
25241   arg1 = (Dali::RenderTask *)jarg1;
25242   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25243   {
25244     try {
25245       (arg1)->SetScreenToFrameBufferFunction(arg2);
25246     } catch (std::out_of_range& e) {
25247       {
25248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25249       };
25250     } catch (std::exception& e) {
25251       {
25252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25253       };
25254     } catch (...) {
25255       {
25256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25257       };
25258     }
25259   }
25260 }
25261
25262
25263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25264   void * jresult ;
25265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25266   Dali::RenderTask::ScreenToFrameBufferFunction result;
25267
25268   arg1 = (Dali::RenderTask *)jarg1;
25269   {
25270     try {
25271       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25272     } catch (std::out_of_range& e) {
25273       {
25274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25275       };
25276     } catch (std::exception& e) {
25277       {
25278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25279       };
25280     } catch (...) {
25281       {
25282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25283       };
25284     }
25285   }
25286   jresult = (void *)result;
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25293   Dali::Actor arg2 ;
25294   Dali::Actor *argp2 ;
25295
25296   arg1 = (Dali::RenderTask *)jarg1;
25297   argp2 = (Dali::Actor *)jarg2;
25298   if (!argp2) {
25299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25300     return ;
25301   }
25302   arg2 = *argp2;
25303   {
25304     try {
25305       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25313       };
25314     } catch (...) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25317       };
25318     }
25319   }
25320 }
25321
25322
25323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25324   void * jresult ;
25325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25326   Dali::Actor result;
25327
25328   arg1 = (Dali::RenderTask *)jarg1;
25329   {
25330     try {
25331       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (...) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25343       };
25344     }
25345   }
25346   jresult = new Dali::Actor((const Dali::Actor &)result);
25347   return jresult;
25348 }
25349
25350
25351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25353   Dali::Vector2 arg2 ;
25354   Dali::Vector2 *argp2 ;
25355
25356   arg1 = (Dali::RenderTask *)jarg1;
25357   argp2 = (Dali::Vector2 *)jarg2;
25358   if (!argp2) {
25359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25360     return ;
25361   }
25362   arg2 = *argp2;
25363   {
25364     try {
25365       (arg1)->SetViewportPosition(arg2);
25366     } catch (std::out_of_range& e) {
25367       {
25368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25369       };
25370     } catch (std::exception& e) {
25371       {
25372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25373       };
25374     } catch (...) {
25375       {
25376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25377       };
25378     }
25379   }
25380 }
25381
25382
25383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25384   void * jresult ;
25385   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25386   Dali::Vector2 result;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   {
25390     try {
25391       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25392     } catch (std::out_of_range& e) {
25393       {
25394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25395       };
25396     } catch (std::exception& e) {
25397       {
25398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25399       };
25400     } catch (...) {
25401       {
25402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25403       };
25404     }
25405   }
25406   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25407   return jresult;
25408 }
25409
25410
25411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25412   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25413   Dali::Vector2 arg2 ;
25414   Dali::Vector2 *argp2 ;
25415
25416   arg1 = (Dali::RenderTask *)jarg1;
25417   argp2 = (Dali::Vector2 *)jarg2;
25418   if (!argp2) {
25419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25420     return ;
25421   }
25422   arg2 = *argp2;
25423   {
25424     try {
25425       (arg1)->SetViewportSize(arg2);
25426     } catch (std::out_of_range& e) {
25427       {
25428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25429       };
25430     } catch (std::exception& e) {
25431       {
25432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25433       };
25434     } catch (...) {
25435       {
25436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25437       };
25438     }
25439   }
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25444   void * jresult ;
25445   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25446   Dali::Vector2 result;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   {
25450     try {
25451       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25467   return jresult;
25468 }
25469
25470
25471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25472   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25473   Dali::Viewport arg2 ;
25474   Dali::Viewport *argp2 ;
25475
25476   arg1 = (Dali::RenderTask *)jarg1;
25477   argp2 = (Dali::Viewport *)jarg2;
25478   if (!argp2) {
25479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25480     return ;
25481   }
25482   arg2 = *argp2;
25483   {
25484     try {
25485       (arg1)->SetViewport(arg2);
25486     } catch (std::out_of_range& e) {
25487       {
25488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25489       };
25490     } catch (std::exception& e) {
25491       {
25492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25493       };
25494     } catch (...) {
25495       {
25496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25497       };
25498     }
25499   }
25500 }
25501
25502
25503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25504   void * jresult ;
25505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25506   Dali::Viewport result;
25507
25508   arg1 = (Dali::RenderTask *)jarg1;
25509   {
25510     try {
25511       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25527   return jresult;
25528 }
25529
25530
25531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25532   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25533   Dali::Vector4 *arg2 = 0 ;
25534
25535   arg1 = (Dali::RenderTask *)jarg1;
25536   arg2 = (Dali::Vector4 *)jarg2;
25537   if (!arg2) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25539     return ;
25540   }
25541   {
25542     try {
25543       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25544     } catch (std::out_of_range& e) {
25545       {
25546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25547       };
25548     } catch (std::exception& e) {
25549       {
25550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25551       };
25552     } catch (...) {
25553       {
25554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25555       };
25556     }
25557   }
25558 }
25559
25560
25561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25562   void * jresult ;
25563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25564   Dali::Vector4 result;
25565
25566   arg1 = (Dali::RenderTask *)jarg1;
25567   {
25568     try {
25569       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25570     } catch (std::out_of_range& e) {
25571       {
25572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25573       };
25574     } catch (std::exception& e) {
25575       {
25576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25581       };
25582     }
25583   }
25584   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25585   return jresult;
25586 }
25587
25588
25589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25590   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25591   bool arg2 ;
25592
25593   arg1 = (Dali::RenderTask *)jarg1;
25594   arg2 = jarg2 ? true : false;
25595   {
25596     try {
25597       (arg1)->SetClearEnabled(arg2);
25598     } catch (std::out_of_range& e) {
25599       {
25600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25601       };
25602     } catch (std::exception& e) {
25603       {
25604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25605       };
25606     } catch (...) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25609       };
25610     }
25611   }
25612 }
25613
25614
25615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25616   unsigned int jresult ;
25617   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25618   bool result;
25619
25620   arg1 = (Dali::RenderTask *)jarg1;
25621   {
25622     try {
25623       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25624     } catch (std::out_of_range& e) {
25625       {
25626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25627       };
25628     } catch (std::exception& e) {
25629       {
25630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25631       };
25632     } catch (...) {
25633       {
25634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25635       };
25636     }
25637   }
25638   jresult = result;
25639   return jresult;
25640 }
25641
25642
25643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25644   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25645   bool arg2 ;
25646
25647   arg1 = (Dali::RenderTask *)jarg1;
25648   arg2 = jarg2 ? true : false;
25649   {
25650     try {
25651       (arg1)->SetCullMode(arg2);
25652     } catch (std::out_of_range& e) {
25653       {
25654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25655       };
25656     } catch (std::exception& e) {
25657       {
25658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25659       };
25660     } catch (...) {
25661       {
25662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25663       };
25664     }
25665   }
25666 }
25667
25668
25669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25670   unsigned int jresult ;
25671   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25672   bool result;
25673
25674   arg1 = (Dali::RenderTask *)jarg1;
25675   {
25676     try {
25677       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25678     } catch (std::out_of_range& e) {
25679       {
25680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25681       };
25682     } catch (std::exception& e) {
25683       {
25684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25685       };
25686     } catch (...) {
25687       {
25688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25689       };
25690     }
25691   }
25692   jresult = result;
25693   return jresult;
25694 }
25695
25696
25697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25698   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25699   unsigned int arg2 ;
25700
25701   arg1 = (Dali::RenderTask *)jarg1;
25702   arg2 = (unsigned int)jarg2;
25703   {
25704     try {
25705       (arg1)->SetRefreshRate(arg2);
25706     } catch (std::out_of_range& e) {
25707       {
25708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25709       };
25710     } catch (std::exception& e) {
25711       {
25712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25713       };
25714     } catch (...) {
25715       {
25716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25717       };
25718     }
25719   }
25720 }
25721
25722
25723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25724   unsigned int jresult ;
25725   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25726   unsigned int result;
25727
25728   arg1 = (Dali::RenderTask *)jarg1;
25729   {
25730     try {
25731       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25732     } catch (std::out_of_range& e) {
25733       {
25734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25735       };
25736     } catch (std::exception& e) {
25737       {
25738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25739       };
25740     } catch (...) {
25741       {
25742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25743       };
25744     }
25745   }
25746   jresult = result;
25747   return jresult;
25748 }
25749
25750
25751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25752   unsigned int jresult ;
25753   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25754   Dali::Vector3 *arg2 = 0 ;
25755   float *arg3 = 0 ;
25756   float *arg4 = 0 ;
25757   bool result;
25758
25759   arg1 = (Dali::RenderTask *)jarg1;
25760   arg2 = (Dali::Vector3 *)jarg2;
25761   if (!arg2) {
25762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25763     return 0;
25764   }
25765   arg3 = (float *)jarg3;
25766   arg4 = (float *)jarg4;
25767   {
25768     try {
25769       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25770     } catch (std::out_of_range& e) {
25771       {
25772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25773       };
25774     } catch (std::exception& e) {
25775       {
25776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25777       };
25778     } catch (...) {
25779       {
25780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25781       };
25782     }
25783   }
25784   jresult = result;
25785   return jresult;
25786 }
25787
25788
25789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25790   unsigned int jresult ;
25791   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25792   Dali::Actor arg2 ;
25793   float arg3 ;
25794   float arg4 ;
25795   float *arg5 = 0 ;
25796   float *arg6 = 0 ;
25797   Dali::Actor *argp2 ;
25798   bool result;
25799
25800   arg1 = (Dali::RenderTask *)jarg1;
25801   argp2 = (Dali::Actor *)jarg2;
25802   if (!argp2) {
25803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25804     return 0;
25805   }
25806   arg2 = *argp2;
25807   arg3 = (float)jarg3;
25808   arg4 = (float)jarg4;
25809   arg5 = (float *)jarg5;
25810   arg6 = (float *)jarg6;
25811   {
25812     try {
25813       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25821       };
25822     } catch (...) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25825       };
25826     }
25827   }
25828   jresult = result;
25829   return jresult;
25830 }
25831
25832
25833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25834   void * jresult ;
25835   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25836   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25837
25838   arg1 = (Dali::RenderTask *)jarg1;
25839   {
25840     try {
25841       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25842     } catch (std::out_of_range& e) {
25843       {
25844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25845       };
25846     } catch (std::exception& e) {
25847       {
25848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25849       };
25850     } catch (...) {
25851       {
25852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25853       };
25854     }
25855   }
25856   jresult = (void *)result;
25857   return jresult;
25858 }
25859
25860
25861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25862   void * jresult ;
25863   int arg1 ;
25864   Dali::TouchPoint::State arg2 ;
25865   float arg3 ;
25866   float arg4 ;
25867   Dali::TouchPoint *result = 0 ;
25868
25869   arg1 = (int)jarg1;
25870   arg2 = (Dali::TouchPoint::State)jarg2;
25871   arg3 = (float)jarg3;
25872   arg4 = (float)jarg4;
25873   {
25874     try {
25875       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25876     } catch (std::out_of_range& e) {
25877       {
25878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25879       };
25880     } catch (std::exception& e) {
25881       {
25882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25883       };
25884     } catch (...) {
25885       {
25886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25887       };
25888     }
25889   }
25890   jresult = (void *)result;
25891   return jresult;
25892 }
25893
25894
25895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25896   void * jresult ;
25897   int arg1 ;
25898   Dali::TouchPoint::State arg2 ;
25899   float arg3 ;
25900   float arg4 ;
25901   float arg5 ;
25902   float arg6 ;
25903   Dali::TouchPoint *result = 0 ;
25904
25905   arg1 = (int)jarg1;
25906   arg2 = (Dali::TouchPoint::State)jarg2;
25907   arg3 = (float)jarg3;
25908   arg4 = (float)jarg4;
25909   arg5 = (float)jarg5;
25910   arg6 = (float)jarg6;
25911   {
25912     try {
25913       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25914     } catch (std::out_of_range& e) {
25915       {
25916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25917       };
25918     } catch (std::exception& e) {
25919       {
25920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25921       };
25922     } catch (...) {
25923       {
25924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25925       };
25926     }
25927   }
25928   jresult = (void *)result;
25929   return jresult;
25930 }
25931
25932
25933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25934   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25935
25936   arg1 = (Dali::TouchPoint *)jarg1;
25937   {
25938     try {
25939       delete arg1;
25940     } catch (std::out_of_range& e) {
25941       {
25942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25943       };
25944     } catch (std::exception& e) {
25945       {
25946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25947       };
25948     } catch (...) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25951       };
25952     }
25953   }
25954 }
25955
25956
25957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25958   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25959   int arg2 ;
25960
25961   arg1 = (Dali::TouchPoint *)jarg1;
25962   arg2 = (int)jarg2;
25963   if (arg1) (arg1)->deviceId = arg2;
25964 }
25965
25966
25967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25968   int jresult ;
25969   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25970   int result;
25971
25972   arg1 = (Dali::TouchPoint *)jarg1;
25973   result = (int) ((arg1)->deviceId);
25974   jresult = result;
25975   return jresult;
25976 }
25977
25978
25979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25980   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25981   Dali::TouchPoint::State arg2 ;
25982
25983   arg1 = (Dali::TouchPoint *)jarg1;
25984   arg2 = (Dali::TouchPoint::State)jarg2;
25985   if (arg1) (arg1)->state = arg2;
25986 }
25987
25988
25989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25990   int jresult ;
25991   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25992   Dali::TouchPoint::State result;
25993
25994   arg1 = (Dali::TouchPoint *)jarg1;
25995   result = (Dali::TouchPoint::State) ((arg1)->state);
25996   jresult = (int)result;
25997   return jresult;
25998 }
25999
26000
26001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26002   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26003   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26004
26005   arg1 = (Dali::TouchPoint *)jarg1;
26006   arg2 = (Dali::Actor *)jarg2;
26007   if (arg1) (arg1)->hitActor = *arg2;
26008 }
26009
26010
26011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26012   void * jresult ;
26013   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26014   Dali::Actor *result = 0 ;
26015
26016   arg1 = (Dali::TouchPoint *)jarg1;
26017   result = (Dali::Actor *)& ((arg1)->hitActor);
26018   jresult = (void *)result;
26019   return jresult;
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26024   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26025   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26026
26027   arg1 = (Dali::TouchPoint *)jarg1;
26028   arg2 = (Dali::Vector2 *)jarg2;
26029   if (arg1) (arg1)->local = *arg2;
26030 }
26031
26032
26033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26034   void * jresult ;
26035   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26036   Dali::Vector2 *result = 0 ;
26037
26038   arg1 = (Dali::TouchPoint *)jarg1;
26039   result = (Dali::Vector2 *)& ((arg1)->local);
26040   jresult = (void *)result;
26041   return jresult;
26042 }
26043
26044
26045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26046   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26047   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26048
26049   arg1 = (Dali::TouchPoint *)jarg1;
26050   arg2 = (Dali::Vector2 *)jarg2;
26051   if (arg1) (arg1)->screen = *arg2;
26052 }
26053
26054
26055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26056   void * jresult ;
26057   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26058   Dali::Vector2 *result = 0 ;
26059
26060   arg1 = (Dali::TouchPoint *)jarg1;
26061   result = (Dali::Vector2 *)& ((arg1)->screen);
26062   jresult = (void *)result;
26063   return jresult;
26064 }
26065
26066
26067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26068   void * jresult ;
26069   Dali::TouchData *result = 0 ;
26070
26071   {
26072     try {
26073       result = (Dali::TouchData *)new Dali::TouchData();
26074     } catch (std::out_of_range& e) {
26075       {
26076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26077       };
26078     } catch (std::exception& e) {
26079       {
26080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26085       };
26086     }
26087   }
26088   jresult = (void *)result;
26089   return jresult;
26090 }
26091
26092
26093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26094   void * jresult ;
26095   Dali::TouchData *arg1 = 0 ;
26096   Dali::TouchData *result = 0 ;
26097
26098   arg1 = (Dali::TouchData *)jarg1;
26099   if (!arg1) {
26100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26101     return 0;
26102   }
26103   {
26104     try {
26105       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26106     } catch (std::out_of_range& e) {
26107       {
26108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26109       };
26110     } catch (std::exception& e) {
26111       {
26112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (...) {
26115       {
26116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26117       };
26118     }
26119   }
26120   jresult = (void *)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26126   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26127
26128   arg1 = (Dali::TouchData *)jarg1;
26129   {
26130     try {
26131       delete arg1;
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26143       };
26144     }
26145   }
26146 }
26147
26148
26149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26150   void * jresult ;
26151   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26152   Dali::TouchData *arg2 = 0 ;
26153   Dali::TouchData *result = 0 ;
26154
26155   arg1 = (Dali::TouchData *)jarg1;
26156   arg2 = (Dali::TouchData *)jarg2;
26157   if (!arg2) {
26158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26159     return 0;
26160   }
26161   {
26162     try {
26163       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26164     } catch (std::out_of_range& e) {
26165       {
26166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26167       };
26168     } catch (std::exception& e) {
26169       {
26170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26171       };
26172     } catch (...) {
26173       {
26174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26175       };
26176     }
26177   }
26178   jresult = (void *)result;
26179   return jresult;
26180 }
26181
26182
26183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26184   unsigned long jresult ;
26185   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26186   unsigned long result;
26187
26188   arg1 = (Dali::TouchData *)jarg1;
26189   {
26190     try {
26191       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26192     } catch (std::out_of_range& e) {
26193       {
26194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (std::exception& e) {
26197       {
26198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26203       };
26204     }
26205   }
26206   jresult = (unsigned long)result;
26207   return jresult;
26208 }
26209
26210
26211 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26212   unsigned long jresult ;
26213   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26214   std::size_t result;
26215
26216   arg1 = (Dali::TouchData *)jarg1;
26217   {
26218     try {
26219       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26220     } catch (std::out_of_range& e) {
26221       {
26222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26223       };
26224     } catch (std::exception& e) {
26225       {
26226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26227       };
26228     } catch (...) {
26229       {
26230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26231       };
26232     }
26233   }
26234   jresult = (unsigned long)result;
26235   return jresult;
26236 }
26237
26238
26239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26240   int jresult ;
26241   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26242   std::size_t arg2 ;
26243   int32_t result;
26244
26245   arg1 = (Dali::TouchData *)jarg1;
26246   arg2 = (std::size_t)jarg2;
26247   {
26248     try {
26249       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26250     } catch (std::out_of_range& e) {
26251       {
26252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26253       };
26254     } catch (std::exception& e) {
26255       {
26256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (...) {
26259       {
26260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26261       };
26262     }
26263   }
26264   jresult = result;
26265   return jresult;
26266 }
26267
26268
26269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26270   int jresult ;
26271   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26272   std::size_t arg2 ;
26273   Dali::PointState::Type result;
26274
26275   arg1 = (Dali::TouchData *)jarg1;
26276   arg2 = (std::size_t)jarg2;
26277   {
26278     try {
26279       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26280     } catch (std::out_of_range& e) {
26281       {
26282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (std::exception& e) {
26285       {
26286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294   jresult = (int)result;
26295   return jresult;
26296 }
26297
26298
26299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26300   void * jresult ;
26301   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26302   std::size_t arg2 ;
26303   Dali::Actor result;
26304
26305   arg1 = (Dali::TouchData *)jarg1;
26306   arg2 = (std::size_t)jarg2;
26307   {
26308     try {
26309       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26310     } catch (std::out_of_range& e) {
26311       {
26312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26313       };
26314     } catch (std::exception& e) {
26315       {
26316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26317       };
26318     } catch (...) {
26319       {
26320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26321       };
26322     }
26323   }
26324   jresult = new Dali::Actor((const Dali::Actor &)result);
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26330   void * jresult ;
26331   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26332   std::size_t arg2 ;
26333   Dali::Vector2 *result = 0 ;
26334
26335   arg1 = (Dali::TouchData *)jarg1;
26336   arg2 = (std::size_t)jarg2;
26337   {
26338     try {
26339       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26340     } catch (std::out_of_range& e) {
26341       {
26342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26343       };
26344     } catch (std::exception& e) {
26345       {
26346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26347       };
26348     } catch (...) {
26349       {
26350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26351       };
26352     }
26353   }
26354   jresult = (void *)result;
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26360   void * jresult ;
26361   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26362   std::size_t arg2 ;
26363   Dali::Vector2 *result = 0 ;
26364
26365   arg1 = (Dali::TouchData *)jarg1;
26366   arg2 = (std::size_t)jarg2;
26367   {
26368     try {
26369       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26370     } catch (std::out_of_range& e) {
26371       {
26372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (std::exception& e) {
26375       {
26376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384   jresult = (void *)result;
26385   return jresult;
26386 }
26387
26388
26389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26390   float jresult ;
26391   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26392   std::size_t arg2 ;
26393   float result;
26394
26395   arg1 = (Dali::TouchData *)jarg1;
26396   arg2 = (std::size_t)jarg2;
26397   {
26398     try {
26399       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26400     } catch (std::out_of_range& e) {
26401       {
26402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26403       };
26404     } catch (std::exception& e) {
26405       {
26406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26407       };
26408     } catch (...) {
26409       {
26410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26411       };
26412     }
26413   }
26414   jresult = result;
26415   return jresult;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26420   void * jresult ;
26421   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26422   std::size_t arg2 ;
26423   Dali::Vector2 *result = 0 ;
26424
26425   arg1 = (Dali::TouchData *)jarg1;
26426   arg2 = (std::size_t)jarg2;
26427   {
26428     try {
26429       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (...) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26441       };
26442     }
26443   }
26444   jresult = (void *)result;
26445   return jresult;
26446 }
26447
26448
26449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26450   float jresult ;
26451   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26452   std::size_t arg2 ;
26453   float result;
26454
26455   arg1 = (Dali::TouchData *)jarg1;
26456   arg2 = (std::size_t)jarg2;
26457   {
26458     try {
26459       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26460     } catch (std::out_of_range& e) {
26461       {
26462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26463       };
26464     } catch (std::exception& e) {
26465       {
26466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26467       };
26468     } catch (...) {
26469       {
26470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26471       };
26472     }
26473   }
26474   jresult = result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26480   void * jresult ;
26481   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26482   std::size_t arg2 ;
26483   Dali::Degree result;
26484
26485   arg1 = (Dali::TouchData *)jarg1;
26486   arg2 = (std::size_t)jarg2;
26487   {
26488     try {
26489       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26490     } catch (std::out_of_range& e) {
26491       {
26492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26493       };
26494     } catch (std::exception& e) {
26495       {
26496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26497       };
26498     } catch (...) {
26499       {
26500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26501       };
26502     }
26503   }
26504   jresult = new Dali::Degree((const Dali::Degree &)result);
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26510   void * jresult ;
26511   Dali::GestureDetector *result = 0 ;
26512
26513   {
26514     try {
26515       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26516     } catch (std::out_of_range& e) {
26517       {
26518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26519       };
26520     } catch (std::exception& e) {
26521       {
26522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26523       };
26524     } catch (...) {
26525       {
26526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26527       };
26528     }
26529   }
26530   jresult = (void *)result;
26531   return jresult;
26532 }
26533
26534
26535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26536   void * jresult ;
26537   Dali::BaseHandle arg1 ;
26538   Dali::BaseHandle *argp1 ;
26539   Dali::GestureDetector result;
26540
26541   argp1 = (Dali::BaseHandle *)jarg1;
26542   if (!argp1) {
26543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26544     return 0;
26545   }
26546   arg1 = *argp1;
26547   {
26548     try {
26549       result = Dali::GestureDetector::DownCast(arg1);
26550     } catch (std::out_of_range& e) {
26551       {
26552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26553       };
26554     } catch (std::exception& e) {
26555       {
26556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26557       };
26558     } catch (...) {
26559       {
26560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26561       };
26562     }
26563   }
26564   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26565   return jresult;
26566 }
26567
26568
26569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26570   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26571
26572   arg1 = (Dali::GestureDetector *)jarg1;
26573   {
26574     try {
26575       delete arg1;
26576     } catch (std::out_of_range& e) {
26577       {
26578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26579       };
26580     } catch (std::exception& e) {
26581       {
26582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26583       };
26584     } catch (...) {
26585       {
26586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26587       };
26588     }
26589   }
26590 }
26591
26592
26593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26594   void * jresult ;
26595   Dali::GestureDetector *arg1 = 0 ;
26596   Dali::GestureDetector *result = 0 ;
26597
26598   arg1 = (Dali::GestureDetector *)jarg1;
26599   if (!arg1) {
26600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26601     return 0;
26602   }
26603   {
26604     try {
26605       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26606     } catch (std::out_of_range& e) {
26607       {
26608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26609       };
26610     } catch (std::exception& e) {
26611       {
26612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26613       };
26614     } catch (...) {
26615       {
26616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26617       };
26618     }
26619   }
26620   jresult = (void *)result;
26621   return jresult;
26622 }
26623
26624
26625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26626   void * jresult ;
26627   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26628   Dali::GestureDetector *arg2 = 0 ;
26629   Dali::GestureDetector *result = 0 ;
26630
26631   arg1 = (Dali::GestureDetector *)jarg1;
26632   arg2 = (Dali::GestureDetector *)jarg2;
26633   if (!arg2) {
26634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26635     return 0;
26636   }
26637   {
26638     try {
26639       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26640     } catch (std::out_of_range& e) {
26641       {
26642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26643       };
26644     } catch (std::exception& e) {
26645       {
26646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26647       };
26648     } catch (...) {
26649       {
26650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26651       };
26652     }
26653   }
26654   jresult = (void *)result;
26655   return jresult;
26656 }
26657
26658
26659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26660   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26661   Dali::Actor arg2 ;
26662   Dali::Actor *argp2 ;
26663
26664   arg1 = (Dali::GestureDetector *)jarg1;
26665   argp2 = (Dali::Actor *)jarg2;
26666   if (!argp2) {
26667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26668     return ;
26669   }
26670   arg2 = *argp2;
26671   {
26672     try {
26673       (arg1)->Attach(arg2);
26674     } catch (std::out_of_range& e) {
26675       {
26676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26677       };
26678     } catch (std::exception& e) {
26679       {
26680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26681       };
26682     } catch (...) {
26683       {
26684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26685       };
26686     }
26687   }
26688 }
26689
26690
26691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26692   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26693   Dali::Actor arg2 ;
26694   Dali::Actor *argp2 ;
26695
26696   arg1 = (Dali::GestureDetector *)jarg1;
26697   argp2 = (Dali::Actor *)jarg2;
26698   if (!argp2) {
26699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26700     return ;
26701   }
26702   arg2 = *argp2;
26703   {
26704     try {
26705       (arg1)->Detach(arg2);
26706     } catch (std::out_of_range& e) {
26707       {
26708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26709       };
26710     } catch (std::exception& e) {
26711       {
26712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26713       };
26714     } catch (...) {
26715       {
26716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26717       };
26718     }
26719   }
26720 }
26721
26722
26723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26724   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26725
26726   arg1 = (Dali::GestureDetector *)jarg1;
26727   {
26728     try {
26729       (arg1)->DetachAll();
26730     } catch (std::out_of_range& e) {
26731       {
26732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26733       };
26734     } catch (std::exception& e) {
26735       {
26736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26737       };
26738     } catch (...) {
26739       {
26740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26741       };
26742     }
26743   }
26744 }
26745
26746
26747 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26748   unsigned long jresult ;
26749   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26750   size_t result;
26751
26752   arg1 = (Dali::GestureDetector *)jarg1;
26753   {
26754     try {
26755       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26756     } catch (std::out_of_range& e) {
26757       {
26758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26759       };
26760     } catch (std::exception& e) {
26761       {
26762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26763       };
26764     } catch (...) {
26765       {
26766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26767       };
26768     }
26769   }
26770   jresult = (unsigned long)result;
26771   return jresult;
26772 }
26773
26774
26775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26776   void * jresult ;
26777   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26778   size_t arg2 ;
26779   Dali::Actor result;
26780
26781   arg1 = (Dali::GestureDetector *)jarg1;
26782   arg2 = (size_t)jarg2;
26783   {
26784     try {
26785       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26786     } catch (std::out_of_range& e) {
26787       {
26788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26789       };
26790     } catch (std::exception& e) {
26791       {
26792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26793       };
26794     } catch (...) {
26795       {
26796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26797       };
26798     }
26799   }
26800   jresult = new Dali::Actor((const Dali::Actor &)result);
26801   return jresult;
26802 }
26803
26804
26805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26806   void * jresult ;
26807   Dali::Gesture *arg1 = 0 ;
26808   Dali::Gesture *result = 0 ;
26809
26810   arg1 = (Dali::Gesture *)jarg1;
26811   if (!arg1) {
26812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26813     return 0;
26814   }
26815   {
26816     try {
26817       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26818     } catch (std::out_of_range& e) {
26819       {
26820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26821       };
26822     } catch (std::exception& e) {
26823       {
26824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26825       };
26826     } catch (...) {
26827       {
26828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26829       };
26830     }
26831   }
26832   jresult = (void *)result;
26833   return jresult;
26834 }
26835
26836
26837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26838   void * jresult ;
26839   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26840   Dali::Gesture *arg2 = 0 ;
26841   Dali::Gesture *result = 0 ;
26842
26843   arg1 = (Dali::Gesture *)jarg1;
26844   arg2 = (Dali::Gesture *)jarg2;
26845   if (!arg2) {
26846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26847     return 0;
26848   }
26849   {
26850     try {
26851       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26852     } catch (std::out_of_range& e) {
26853       {
26854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26855       };
26856     } catch (std::exception& e) {
26857       {
26858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26859       };
26860     } catch (...) {
26861       {
26862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26863       };
26864     }
26865   }
26866   jresult = (void *)result;
26867   return jresult;
26868 }
26869
26870
26871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26872   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26873
26874   arg1 = (Dali::Gesture *)jarg1;
26875   {
26876     try {
26877       delete arg1;
26878     } catch (std::out_of_range& e) {
26879       {
26880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26881       };
26882     } catch (std::exception& e) {
26883       {
26884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26889       };
26890     }
26891   }
26892 }
26893
26894
26895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26896   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26897   Dali::Gesture::Type arg2 ;
26898
26899   arg1 = (Dali::Gesture *)jarg1;
26900   arg2 = (Dali::Gesture::Type)jarg2;
26901   if (arg1) (arg1)->type = arg2;
26902 }
26903
26904
26905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26906   int jresult ;
26907   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26908   Dali::Gesture::Type result;
26909
26910   arg1 = (Dali::Gesture *)jarg1;
26911   result = (Dali::Gesture::Type) ((arg1)->type);
26912   jresult = (int)result;
26913   return jresult;
26914 }
26915
26916
26917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26918   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26919   Dali::Gesture::State arg2 ;
26920
26921   arg1 = (Dali::Gesture *)jarg1;
26922   arg2 = (Dali::Gesture::State)jarg2;
26923   if (arg1) (arg1)->state = arg2;
26924 }
26925
26926
26927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26928   int jresult ;
26929   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26930   Dali::Gesture::State result;
26931
26932   arg1 = (Dali::Gesture *)jarg1;
26933   result = (Dali::Gesture::State) ((arg1)->state);
26934   jresult = (int)result;
26935   return jresult;
26936 }
26937
26938
26939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26940   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26941   unsigned int arg2 ;
26942
26943   arg1 = (Dali::Gesture *)jarg1;
26944   arg2 = (unsigned int)jarg2;
26945   if (arg1) (arg1)->time = arg2;
26946 }
26947
26948
26949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26950   unsigned int jresult ;
26951   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26952   unsigned int result;
26953
26954   arg1 = (Dali::Gesture *)jarg1;
26955   result = (unsigned int) ((arg1)->time);
26956   jresult = result;
26957   return jresult;
26958 }
26959
26960
26961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26962   void * jresult ;
26963   Dali::HoverEvent *result = 0 ;
26964
26965   {
26966     try {
26967       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26968     } catch (std::out_of_range& e) {
26969       {
26970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26971       };
26972     } catch (std::exception& e) {
26973       {
26974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26975       };
26976     } catch (...) {
26977       {
26978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26979       };
26980     }
26981   }
26982   jresult = (void *)result;
26983   return jresult;
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26988   void * jresult ;
26989   unsigned long arg1 ;
26990   Dali::HoverEvent *result = 0 ;
26991
26992   arg1 = (unsigned long)jarg1;
26993   {
26994     try {
26995       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26996     } catch (std::out_of_range& e) {
26997       {
26998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26999       };
27000     } catch (std::exception& e) {
27001       {
27002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (...) {
27005       {
27006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27007       };
27008     }
27009   }
27010   jresult = (void *)result;
27011   return jresult;
27012 }
27013
27014
27015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27016   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27017
27018   arg1 = (Dali::HoverEvent *)jarg1;
27019   {
27020     try {
27021       delete arg1;
27022     } catch (std::out_of_range& e) {
27023       {
27024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27025       };
27026     } catch (std::exception& e) {
27027       {
27028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27029       };
27030     } catch (...) {
27031       {
27032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27033       };
27034     }
27035   }
27036 }
27037
27038
27039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27040   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27041   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27042
27043   arg1 = (Dali::HoverEvent *)jarg1;
27044   arg2 = (Dali::TouchPointContainer *)jarg2;
27045   if (arg1) (arg1)->points = *arg2;
27046 }
27047
27048
27049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27050   void * jresult ;
27051   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27052   Dali::TouchPointContainer *result = 0 ;
27053
27054   arg1 = (Dali::HoverEvent *)jarg1;
27055   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27056   jresult = (void *)result;
27057   return jresult;
27058 }
27059
27060
27061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27062   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27063   unsigned long arg2 ;
27064
27065   arg1 = (Dali::HoverEvent *)jarg1;
27066   arg2 = (unsigned long)jarg2;
27067   if (arg1) (arg1)->time = arg2;
27068 }
27069
27070
27071 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27072   unsigned long jresult ;
27073   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27074   unsigned long result;
27075
27076   arg1 = (Dali::HoverEvent *)jarg1;
27077   result = (unsigned long) ((arg1)->time);
27078   jresult = (unsigned long)result;
27079   return jresult;
27080 }
27081
27082
27083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27084   unsigned int jresult ;
27085   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27086   unsigned int result;
27087
27088   arg1 = (Dali::HoverEvent *)jarg1;
27089   {
27090     try {
27091       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (...) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27103       };
27104     }
27105   }
27106   jresult = result;
27107   return jresult;
27108 }
27109
27110
27111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27112   void * jresult ;
27113   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27114   unsigned int arg2 ;
27115   Dali::TouchPoint *result = 0 ;
27116
27117   arg1 = (Dali::HoverEvent *)jarg1;
27118   arg2 = (unsigned int)jarg2;
27119   {
27120     try {
27121       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27122     } catch (std::out_of_range& e) {
27123       {
27124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27125       };
27126     } catch (std::exception& e) {
27127       {
27128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27129       };
27130     } catch (...) {
27131       {
27132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27133       };
27134     }
27135   }
27136   jresult = (void *)result;
27137   return jresult;
27138 }
27139
27140
27141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27142   void * jresult ;
27143   Dali::KeyEvent *result = 0 ;
27144
27145   {
27146     try {
27147       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27148     } catch (std::out_of_range& e) {
27149       {
27150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27151       };
27152     } catch (std::exception& e) {
27153       {
27154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (...) {
27157       {
27158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27159       };
27160     }
27161   }
27162   jresult = (void *)result;
27163   return jresult;
27164 }
27165
27166
27167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27168   void * jresult ;
27169   std::string *arg1 = 0 ;
27170   std::string *arg2 = 0 ;
27171   int arg3 ;
27172   int arg4 ;
27173   unsigned long arg5 ;
27174   Dali::KeyEvent::State *arg6 = 0 ;
27175   Dali::KeyEvent::State temp6 ;
27176   Dali::KeyEvent *result = 0 ;
27177
27178   if (!jarg1) {
27179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27180     return 0;
27181   }
27182   std::string arg1_str(jarg1);
27183   arg1 = &arg1_str;
27184   if (!jarg2) {
27185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27186     return 0;
27187   }
27188   std::string arg2_str(jarg2);
27189   arg2 = &arg2_str;
27190   arg3 = (int)jarg3;
27191   arg4 = (int)jarg4;
27192   arg5 = (unsigned long)jarg5;
27193   temp6 = (Dali::KeyEvent::State)jarg6;
27194   arg6 = &temp6;
27195   {
27196     try {
27197       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27198     } catch (std::out_of_range& e) {
27199       {
27200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27201       };
27202     } catch (std::exception& e) {
27203       {
27204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27205       };
27206     } catch (...) {
27207       {
27208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27209       };
27210     }
27211   }
27212   jresult = (void *)result;
27213
27214   //argout typemap for const std::string&
27215
27216
27217   //argout typemap for const std::string&
27218
27219   return jresult;
27220 }
27221
27222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27223   void * jresult ;
27224   Dali::KeyEvent *arg1 = 0 ;
27225   Dali::KeyEvent *result = 0 ;
27226
27227   arg1 = (Dali::KeyEvent *)jarg1;
27228   if (!arg1) {
27229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27230     return 0;
27231   }
27232   {
27233     try {
27234       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27235     } catch (std::out_of_range& e) {
27236       {
27237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27238       };
27239     } catch (std::exception& e) {
27240       {
27241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27242       };
27243     } catch (...) {
27244       {
27245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27246       };
27247     }
27248   }
27249   jresult = (void *)result;
27250   return jresult;
27251 }
27252
27253
27254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27255   void * jresult ;
27256   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27257   Dali::KeyEvent *arg2 = 0 ;
27258   Dali::KeyEvent *result = 0 ;
27259
27260   arg1 = (Dali::KeyEvent *)jarg1;
27261   arg2 = (Dali::KeyEvent *)jarg2;
27262   if (!arg2) {
27263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27264     return 0;
27265   }
27266   {
27267     try {
27268       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27269     } catch (std::out_of_range& e) {
27270       {
27271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27272       };
27273     } catch (std::exception& e) {
27274       {
27275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27276       };
27277     } catch (...) {
27278       {
27279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27280       };
27281     }
27282   }
27283   jresult = (void *)result;
27284   return jresult;
27285 }
27286
27287
27288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27289   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27290
27291   arg1 = (Dali::KeyEvent *)jarg1;
27292   {
27293     try {
27294       delete arg1;
27295     } catch (std::out_of_range& e) {
27296       {
27297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27298       };
27299     } catch (std::exception& e) {
27300       {
27301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27302       };
27303     } catch (...) {
27304       {
27305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27306       };
27307     }
27308   }
27309 }
27310
27311
27312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27313   unsigned int jresult ;
27314   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27315   bool result;
27316
27317   arg1 = (Dali::KeyEvent *)jarg1;
27318   {
27319     try {
27320       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27321     } catch (std::out_of_range& e) {
27322       {
27323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (std::exception& e) {
27326       {
27327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (...) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27332       };
27333     }
27334   }
27335   jresult = result;
27336   return jresult;
27337 }
27338
27339
27340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27341   unsigned int jresult ;
27342   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27343   bool result;
27344
27345   arg1 = (Dali::KeyEvent *)jarg1;
27346   {
27347     try {
27348       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27349     } catch (std::out_of_range& e) {
27350       {
27351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27352       };
27353     } catch (std::exception& e) {
27354       {
27355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27356       };
27357     } catch (...) {
27358       {
27359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27360       };
27361     }
27362   }
27363   jresult = result;
27364   return jresult;
27365 }
27366
27367
27368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27369   unsigned int jresult ;
27370   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27371   bool result;
27372
27373   arg1 = (Dali::KeyEvent *)jarg1;
27374   {
27375     try {
27376       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27384       };
27385     } catch (...) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27388       };
27389     }
27390   }
27391   jresult = result;
27392   return jresult;
27393 }
27394
27395
27396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   std::string *arg2 = 0 ;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   if (!jarg2) {
27402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27403     return ;
27404   }
27405   std::string arg2_str(jarg2);
27406   arg2 = &arg2_str;
27407   if (arg1) (arg1)->keyPressedName = *arg2;
27408
27409   //argout typemap for const std::string&
27410
27411 }
27412
27413
27414 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27415   char * jresult ;
27416   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27417   std::string *result = 0 ;
27418
27419   arg1 = (Dali::KeyEvent *)jarg1;
27420   result = (std::string *) & ((arg1)->keyPressedName);
27421   jresult = SWIG_csharp_string_callback(result->c_str());
27422   return jresult;
27423 }
27424
27425
27426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27428   std::string *arg2 = 0 ;
27429
27430   arg1 = (Dali::KeyEvent *)jarg1;
27431   if (!jarg2) {
27432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27433     return ;
27434   }
27435   std::string arg2_str(jarg2);
27436   arg2 = &arg2_str;
27437   if (arg1) (arg1)->keyPressed = *arg2;
27438
27439   //argout typemap for const std::string&
27440
27441 }
27442
27443
27444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27445   char * jresult ;
27446   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27447   std::string *result = 0 ;
27448
27449   arg1 = (Dali::KeyEvent *)jarg1;
27450   result = (std::string *) & ((arg1)->keyPressed);
27451   jresult = SWIG_csharp_string_callback(result->c_str());
27452   return jresult;
27453 }
27454
27455
27456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27457   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27458   int arg2 ;
27459
27460   arg1 = (Dali::KeyEvent *)jarg1;
27461   arg2 = (int)jarg2;
27462   if (arg1) (arg1)->keyCode = arg2;
27463 }
27464
27465
27466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27467   int jresult ;
27468   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27469   int result;
27470
27471   arg1 = (Dali::KeyEvent *)jarg1;
27472   result = (int) ((arg1)->keyCode);
27473   jresult = result;
27474   return jresult;
27475 }
27476
27477
27478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27479   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27480   int arg2 ;
27481
27482   arg1 = (Dali::KeyEvent *)jarg1;
27483   arg2 = (int)jarg2;
27484   if (arg1) (arg1)->keyModifier = arg2;
27485 }
27486
27487
27488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27489   int jresult ;
27490   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27491   int result;
27492
27493   arg1 = (Dali::KeyEvent *)jarg1;
27494   result = (int) ((arg1)->keyModifier);
27495   jresult = result;
27496   return jresult;
27497 }
27498
27499
27500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27501   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27502   unsigned long arg2 ;
27503
27504   arg1 = (Dali::KeyEvent *)jarg1;
27505   arg2 = (unsigned long)jarg2;
27506   if (arg1) (arg1)->time = arg2;
27507 }
27508
27509
27510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27511   unsigned long jresult ;
27512   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27513   unsigned long result;
27514
27515   arg1 = (Dali::KeyEvent *)jarg1;
27516   result = (unsigned long) ((arg1)->time);
27517   jresult = (unsigned long)result;
27518   return jresult;
27519 }
27520
27521
27522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27523   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27524   Dali::KeyEvent::State arg2 ;
27525
27526   arg1 = (Dali::KeyEvent *)jarg1;
27527   arg2 = (Dali::KeyEvent::State)jarg2;
27528   if (arg1) (arg1)->state = arg2;
27529 }
27530
27531
27532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27533   int jresult ;
27534   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27535   Dali::KeyEvent::State result;
27536
27537   arg1 = (Dali::KeyEvent *)jarg1;
27538   result = (Dali::KeyEvent::State) ((arg1)->state);
27539   jresult = (int)result;
27540   return jresult;
27541 }
27542
27543
27544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27545   void * jresult ;
27546   Dali::LongPressGestureDetector *result = 0 ;
27547
27548   {
27549     try {
27550       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27551     } catch (std::out_of_range& e) {
27552       {
27553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27554       };
27555     } catch (std::exception& e) {
27556       {
27557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27558       };
27559     } catch (...) {
27560       {
27561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27562       };
27563     }
27564   }
27565   jresult = (void *)result;
27566   return jresult;
27567 }
27568
27569
27570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27571   void * jresult ;
27572   Dali::LongPressGestureDetector result;
27573
27574   {
27575     try {
27576       result = Dali::LongPressGestureDetector::New();
27577     } catch (std::out_of_range& e) {
27578       {
27579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27580       };
27581     } catch (std::exception& e) {
27582       {
27583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27584       };
27585     } catch (...) {
27586       {
27587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27588       };
27589     }
27590   }
27591   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27592   return jresult;
27593 }
27594
27595
27596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27597   void * jresult ;
27598   unsigned int arg1 ;
27599   Dali::LongPressGestureDetector result;
27600
27601   arg1 = (unsigned int)jarg1;
27602   {
27603     try {
27604       result = Dali::LongPressGestureDetector::New(arg1);
27605     } catch (std::out_of_range& e) {
27606       {
27607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27608       };
27609     } catch (std::exception& e) {
27610       {
27611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27612       };
27613     } catch (...) {
27614       {
27615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27616       };
27617     }
27618   }
27619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27620   return jresult;
27621 }
27622
27623
27624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27625   void * jresult ;
27626   unsigned int arg1 ;
27627   unsigned int arg2 ;
27628   Dali::LongPressGestureDetector result;
27629
27630   arg1 = (unsigned int)jarg1;
27631   arg2 = (unsigned int)jarg2;
27632   {
27633     try {
27634       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27635     } catch (std::out_of_range& e) {
27636       {
27637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27638       };
27639     } catch (std::exception& e) {
27640       {
27641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27642       };
27643     } catch (...) {
27644       {
27645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27646       };
27647     }
27648   }
27649   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27650   return jresult;
27651 }
27652
27653
27654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27655   void * jresult ;
27656   Dali::BaseHandle arg1 ;
27657   Dali::BaseHandle *argp1 ;
27658   Dali::LongPressGestureDetector result;
27659
27660   argp1 = (Dali::BaseHandle *)jarg1;
27661   if (!argp1) {
27662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27663     return 0;
27664   }
27665   arg1 = *argp1;
27666   {
27667     try {
27668       result = Dali::LongPressGestureDetector::DownCast(arg1);
27669     } catch (std::out_of_range& e) {
27670       {
27671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27672       };
27673     } catch (std::exception& e) {
27674       {
27675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27676       };
27677     } catch (...) {
27678       {
27679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27680       };
27681     }
27682   }
27683   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27684   return jresult;
27685 }
27686
27687
27688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27689   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27690
27691   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27692   {
27693     try {
27694       delete arg1;
27695     } catch (std::out_of_range& e) {
27696       {
27697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27698       };
27699     } catch (std::exception& e) {
27700       {
27701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27706       };
27707     }
27708   }
27709 }
27710
27711
27712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27713   void * jresult ;
27714   Dali::LongPressGestureDetector *arg1 = 0 ;
27715   Dali::LongPressGestureDetector *result = 0 ;
27716
27717   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27718   if (!arg1) {
27719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27720     return 0;
27721   }
27722   {
27723     try {
27724       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (...) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27736       };
27737     }
27738   }
27739   jresult = (void *)result;
27740   return jresult;
27741 }
27742
27743
27744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27745   void * jresult ;
27746   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27747   Dali::LongPressGestureDetector *arg2 = 0 ;
27748   Dali::LongPressGestureDetector *result = 0 ;
27749
27750   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27751   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27752   if (!arg2) {
27753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27754     return 0;
27755   }
27756   {
27757     try {
27758       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27759     } catch (std::out_of_range& e) {
27760       {
27761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27762       };
27763     } catch (std::exception& e) {
27764       {
27765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27766       };
27767     } catch (...) {
27768       {
27769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27770       };
27771     }
27772   }
27773   jresult = (void *)result;
27774   return jresult;
27775 }
27776
27777
27778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27779   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27780   unsigned int arg2 ;
27781
27782   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27783   arg2 = (unsigned int)jarg2;
27784   {
27785     try {
27786       (arg1)->SetTouchesRequired(arg2);
27787     } catch (std::out_of_range& e) {
27788       {
27789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27790       };
27791     } catch (std::exception& e) {
27792       {
27793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27794       };
27795     } catch (...) {
27796       {
27797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27798       };
27799     }
27800   }
27801 }
27802
27803
27804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27805   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27806   unsigned int arg2 ;
27807   unsigned int arg3 ;
27808
27809   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27810   arg2 = (unsigned int)jarg2;
27811   arg3 = (unsigned int)jarg3;
27812   {
27813     try {
27814       (arg1)->SetTouchesRequired(arg2,arg3);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27822       };
27823     } catch (...) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27826       };
27827     }
27828   }
27829 }
27830
27831
27832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27833   unsigned int jresult ;
27834   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27835   unsigned int result;
27836
27837   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27838   {
27839     try {
27840       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27841     } catch (std::out_of_range& e) {
27842       {
27843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27844       };
27845     } catch (std::exception& e) {
27846       {
27847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27848       };
27849     } catch (...) {
27850       {
27851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27852       };
27853     }
27854   }
27855   jresult = result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27861   unsigned int jresult ;
27862   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27863   unsigned int result;
27864
27865   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27866   {
27867     try {
27868       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (...) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27880       };
27881     }
27882   }
27883   jresult = result;
27884   return jresult;
27885 }
27886
27887
27888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27889   void * jresult ;
27890   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27891   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27892
27893   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27894   {
27895     try {
27896       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27897     } catch (std::out_of_range& e) {
27898       {
27899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27900       };
27901     } catch (std::exception& e) {
27902       {
27903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27904       };
27905     } catch (...) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27908       };
27909     }
27910   }
27911   jresult = (void *)result;
27912   return jresult;
27913 }
27914
27915
27916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27917   void * jresult ;
27918   Dali::Gesture::State arg1 ;
27919   Dali::LongPressGesture *result = 0 ;
27920
27921   arg1 = (Dali::Gesture::State)jarg1;
27922   {
27923     try {
27924       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27925     } catch (std::out_of_range& e) {
27926       {
27927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27928       };
27929     } catch (std::exception& e) {
27930       {
27931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27932       };
27933     } catch (...) {
27934       {
27935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27936       };
27937     }
27938   }
27939   jresult = (void *)result;
27940   return jresult;
27941 }
27942
27943
27944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27945   void * jresult ;
27946   Dali::LongPressGesture *arg1 = 0 ;
27947   Dali::LongPressGesture *result = 0 ;
27948
27949   arg1 = (Dali::LongPressGesture *)jarg1;
27950   if (!arg1) {
27951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27952     return 0;
27953   }
27954   {
27955     try {
27956       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (...) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27968       };
27969     }
27970   }
27971   jresult = (void *)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27977   void * jresult ;
27978   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27979   Dali::LongPressGesture *arg2 = 0 ;
27980   Dali::LongPressGesture *result = 0 ;
27981
27982   arg1 = (Dali::LongPressGesture *)jarg1;
27983   arg2 = (Dali::LongPressGesture *)jarg2;
27984   if (!arg2) {
27985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27986     return 0;
27987   }
27988   {
27989     try {
27990       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27991     } catch (std::out_of_range& e) {
27992       {
27993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27994       };
27995     } catch (std::exception& e) {
27996       {
27997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27998       };
27999     } catch (...) {
28000       {
28001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28002       };
28003     }
28004   }
28005   jresult = (void *)result;
28006   return jresult;
28007 }
28008
28009
28010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28011   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28012
28013   arg1 = (Dali::LongPressGesture *)jarg1;
28014   {
28015     try {
28016       delete arg1;
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28028       };
28029     }
28030   }
28031 }
28032
28033
28034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28035   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28036   unsigned int arg2 ;
28037
28038   arg1 = (Dali::LongPressGesture *)jarg1;
28039   arg2 = (unsigned int)jarg2;
28040   if (arg1) (arg1)->numberOfTouches = arg2;
28041 }
28042
28043
28044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28045   unsigned int jresult ;
28046   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28047   unsigned int result;
28048
28049   arg1 = (Dali::LongPressGesture *)jarg1;
28050   result = (unsigned int) ((arg1)->numberOfTouches);
28051   jresult = result;
28052   return jresult;
28053 }
28054
28055
28056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28057   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28058   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28059
28060   arg1 = (Dali::LongPressGesture *)jarg1;
28061   arg2 = (Dali::Vector2 *)jarg2;
28062   if (arg1) (arg1)->screenPoint = *arg2;
28063 }
28064
28065
28066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28067   void * jresult ;
28068   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28069   Dali::Vector2 *result = 0 ;
28070
28071   arg1 = (Dali::LongPressGesture *)jarg1;
28072   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28073   jresult = (void *)result;
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28079   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28080   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28081
28082   arg1 = (Dali::LongPressGesture *)jarg1;
28083   arg2 = (Dali::Vector2 *)jarg2;
28084   if (arg1) (arg1)->localPoint = *arg2;
28085 }
28086
28087
28088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28089   void * jresult ;
28090   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28091   Dali::Vector2 *result = 0 ;
28092
28093   arg1 = (Dali::LongPressGesture *)jarg1;
28094   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28095   jresult = (void *)result;
28096   return jresult;
28097 }
28098
28099
28100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28101   void * jresult ;
28102   Dali::WheelEvent *result = 0 ;
28103
28104   {
28105     try {
28106       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28107     } catch (std::out_of_range& e) {
28108       {
28109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28110       };
28111     } catch (std::exception& e) {
28112       {
28113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28114       };
28115     } catch (...) {
28116       {
28117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28118       };
28119     }
28120   }
28121   jresult = (void *)result;
28122   return jresult;
28123 }
28124
28125
28126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28127   void * jresult ;
28128   Dali::WheelEvent::Type arg1 ;
28129   int arg2 ;
28130   unsigned int arg3 ;
28131   Dali::Vector2 arg4 ;
28132   int arg5 ;
28133   unsigned int arg6 ;
28134   Dali::Vector2 *argp4 ;
28135   Dali::WheelEvent *result = 0 ;
28136
28137   arg1 = (Dali::WheelEvent::Type)jarg1;
28138   arg2 = (int)jarg2;
28139   arg3 = (unsigned int)jarg3;
28140   argp4 = (Dali::Vector2 *)jarg4;
28141   if (!argp4) {
28142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28143     return 0;
28144   }
28145   arg4 = *argp4;
28146   arg5 = (int)jarg5;
28147   arg6 = (unsigned int)jarg6;
28148   {
28149     try {
28150       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28151     } catch (std::out_of_range& e) {
28152       {
28153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28154       };
28155     } catch (std::exception& e) {
28156       {
28157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28158       };
28159     } catch (...) {
28160       {
28161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28162       };
28163     }
28164   }
28165   jresult = (void *)result;
28166   return jresult;
28167 }
28168
28169
28170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28171   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28172
28173   arg1 = (Dali::WheelEvent *)jarg1;
28174   {
28175     try {
28176       delete arg1;
28177     } catch (std::out_of_range& e) {
28178       {
28179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28180       };
28181     } catch (std::exception& e) {
28182       {
28183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28184       };
28185     } catch (...) {
28186       {
28187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28188       };
28189     }
28190   }
28191 }
28192
28193
28194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28195   unsigned int jresult ;
28196   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28197   bool result;
28198
28199   arg1 = (Dali::WheelEvent *)jarg1;
28200   {
28201     try {
28202       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28203     } catch (std::out_of_range& e) {
28204       {
28205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28206       };
28207     } catch (std::exception& e) {
28208       {
28209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (...) {
28212       {
28213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28214       };
28215     }
28216   }
28217   jresult = result;
28218   return jresult;
28219 }
28220
28221
28222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28223   unsigned int jresult ;
28224   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28225   bool result;
28226
28227   arg1 = (Dali::WheelEvent *)jarg1;
28228   {
28229     try {
28230       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28231     } catch (std::out_of_range& e) {
28232       {
28233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28234       };
28235     } catch (std::exception& e) {
28236       {
28237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28238       };
28239     } catch (...) {
28240       {
28241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28242       };
28243     }
28244   }
28245   jresult = result;
28246   return jresult;
28247 }
28248
28249
28250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28251   unsigned int jresult ;
28252   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28253   bool result;
28254
28255   arg1 = (Dali::WheelEvent *)jarg1;
28256   {
28257     try {
28258       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28259     } catch (std::out_of_range& e) {
28260       {
28261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28262       };
28263     } catch (std::exception& e) {
28264       {
28265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28266       };
28267     } catch (...) {
28268       {
28269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28270       };
28271     }
28272   }
28273   jresult = result;
28274   return jresult;
28275 }
28276
28277
28278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   Dali::WheelEvent::Type arg2 ;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   arg2 = (Dali::WheelEvent::Type)jarg2;
28284   if (arg1) (arg1)->type = arg2;
28285 }
28286
28287
28288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28289   int jresult ;
28290   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28291   Dali::WheelEvent::Type result;
28292
28293   arg1 = (Dali::WheelEvent *)jarg1;
28294   result = (Dali::WheelEvent::Type) ((arg1)->type);
28295   jresult = (int)result;
28296   return jresult;
28297 }
28298
28299
28300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28301   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28302   int arg2 ;
28303
28304   arg1 = (Dali::WheelEvent *)jarg1;
28305   arg2 = (int)jarg2;
28306   if (arg1) (arg1)->direction = arg2;
28307 }
28308
28309
28310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28311   int jresult ;
28312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28313   int result;
28314
28315   arg1 = (Dali::WheelEvent *)jarg1;
28316   result = (int) ((arg1)->direction);
28317   jresult = result;
28318   return jresult;
28319 }
28320
28321
28322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28323   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28324   unsigned int arg2 ;
28325
28326   arg1 = (Dali::WheelEvent *)jarg1;
28327   arg2 = (unsigned int)jarg2;
28328   if (arg1) (arg1)->modifiers = arg2;
28329 }
28330
28331
28332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28333   unsigned int jresult ;
28334   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28335   unsigned int result;
28336
28337   arg1 = (Dali::WheelEvent *)jarg1;
28338   result = (unsigned int) ((arg1)->modifiers);
28339   jresult = result;
28340   return jresult;
28341 }
28342
28343
28344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28345   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28346   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28347
28348   arg1 = (Dali::WheelEvent *)jarg1;
28349   arg2 = (Dali::Vector2 *)jarg2;
28350   if (arg1) (arg1)->point = *arg2;
28351 }
28352
28353
28354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28355   void * jresult ;
28356   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28357   Dali::Vector2 *result = 0 ;
28358
28359   arg1 = (Dali::WheelEvent *)jarg1;
28360   result = (Dali::Vector2 *)& ((arg1)->point);
28361   jresult = (void *)result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28367   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28368   int arg2 ;
28369
28370   arg1 = (Dali::WheelEvent *)jarg1;
28371   arg2 = (int)jarg2;
28372   if (arg1) (arg1)->z = arg2;
28373 }
28374
28375
28376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28377   int jresult ;
28378   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28379   int result;
28380
28381   arg1 = (Dali::WheelEvent *)jarg1;
28382   result = (int) ((arg1)->z);
28383   jresult = result;
28384   return jresult;
28385 }
28386
28387
28388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28389   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28390   unsigned int arg2 ;
28391
28392   arg1 = (Dali::WheelEvent *)jarg1;
28393   arg2 = (unsigned int)jarg2;
28394   if (arg1) (arg1)->timeStamp = arg2;
28395 }
28396
28397
28398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28399   unsigned int jresult ;
28400   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28401   unsigned int result;
28402
28403   arg1 = (Dali::WheelEvent *)jarg1;
28404   result = (unsigned int) ((arg1)->timeStamp);
28405   jresult = result;
28406   return jresult;
28407 }
28408
28409 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28410   char * jresult ;
28411   Dali::KeyEvent *arg1 = 0 ;
28412   std::string result;
28413
28414   arg1 = (Dali::KeyEvent *)jarg1;
28415   if (!arg1) {
28416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28417     return 0;
28418   }
28419   {
28420     try {
28421       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28422     } catch (std::out_of_range& e) {
28423       {
28424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28425       };
28426     } catch (std::exception& e) {
28427       {
28428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28429       };
28430     } catch (...) {
28431       {
28432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28433       };
28434     }
28435   }
28436   jresult = SWIG_csharp_string_callback((&result)->c_str());
28437   return jresult;
28438 }
28439
28440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28441   int jresult ;
28442   Dali::KeyEvent *arg1 = 0 ;
28443   Dali::DevelDevice::Class::Type result;
28444
28445   arg1 = (Dali::KeyEvent *)jarg1;
28446   if (!arg1) {
28447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28448     return 0;
28449   }
28450   {
28451     try {
28452       result = (Dali::DevelDevice::Class::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28453     } catch (std::out_of_range& e) {
28454       {
28455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28456       };
28457     } catch (std::exception& e) {
28458       {
28459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28460       };
28461     } catch (...) {
28462       {
28463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28464       };
28465     }
28466   }
28467   jresult = (int)result;
28468   return jresult;
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
28473   Dali::Actor arg1 ;
28474   Dali::Actor *argp1 ;
28475
28476   argp1 = (Dali::Actor *)jarg1;
28477   if (!argp1) {
28478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28479     return ;
28480   }
28481   arg1 = *argp1;
28482   {
28483     try {
28484       Dali::DevelActor::Raise(arg1);
28485     } catch (std::out_of_range& e) {
28486       {
28487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28488       };
28489     } catch (std::exception& e) {
28490       {
28491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28496       };
28497     }
28498   }
28499 }
28500
28501
28502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
28503   Dali::Actor arg1 ;
28504   Dali::Actor *argp1 ;
28505
28506   argp1 = (Dali::Actor *)jarg1;
28507   if (!argp1) {
28508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28509     return ;
28510   }
28511   arg1 = *argp1;
28512   {
28513     try {
28514       Dali::DevelActor::Lower(arg1);
28515     } catch (std::out_of_range& e) {
28516       {
28517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28518       };
28519     } catch (std::exception& e) {
28520       {
28521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28522       };
28523     } catch (...) {
28524       {
28525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28526       };
28527     }
28528   }
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
28533   Dali::Actor arg1 ;
28534   Dali::Actor *argp1 ;
28535
28536   argp1 = (Dali::Actor *)jarg1;
28537   if (!argp1) {
28538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28539     return ;
28540   }
28541   arg1 = *argp1;
28542   {
28543     try {
28544       Dali::DevelActor::RaiseToTop(arg1);
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (...) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28556       };
28557     }
28558   }
28559 }
28560
28561
28562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
28563   Dali::Actor arg1 ;
28564   Dali::Actor *argp1 ;
28565
28566   argp1 = (Dali::Actor *)jarg1;
28567   if (!argp1) {
28568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28569     return ;
28570   }
28571   arg1 = *argp1;
28572   {
28573     try {
28574       Dali::DevelActor::LowerToBottom(arg1);
28575     } catch (std::out_of_range& e) {
28576       {
28577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28578       };
28579     } catch (std::exception& e) {
28580       {
28581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28582       };
28583     } catch (...) {
28584       {
28585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28586       };
28587     }
28588   }
28589 }
28590
28591
28592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
28593   Dali::Actor arg1 ;
28594   Dali::Actor arg2 ;
28595   Dali::Actor *argp1 ;
28596   Dali::Actor *argp2 ;
28597
28598   argp1 = (Dali::Actor *)jarg1;
28599   if (!argp1) {
28600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28601     return ;
28602   }
28603   arg1 = *argp1;
28604   argp2 = (Dali::Actor *)jarg2;
28605   if (!argp2) {
28606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28607     return ;
28608   }
28609   arg2 = *argp2;
28610   {
28611     try {
28612       Dali::DevelActor::RaiseAbove(arg1,arg2);
28613     } catch (std::out_of_range& e) {
28614       {
28615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28616       };
28617     } catch (std::exception& e) {
28618       {
28619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28620       };
28621     } catch (...) {
28622       {
28623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28624       };
28625     }
28626   }
28627 }
28628
28629
28630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
28631   Dali::Actor arg1 ;
28632   Dali::Actor arg2 ;
28633   Dali::Actor *argp1 ;
28634   Dali::Actor *argp2 ;
28635
28636   argp1 = (Dali::Actor *)jarg1;
28637   if (!argp1) {
28638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28639     return ;
28640   }
28641   arg1 = *argp1;
28642   argp2 = (Dali::Actor *)jarg2;
28643   if (!argp2) {
28644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28645     return ;
28646   }
28647   arg2 = *argp2;
28648   {
28649     try {
28650       Dali::DevelActor::LowerBelow(arg1,arg2);
28651     } catch (std::out_of_range& e) {
28652       {
28653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28654       };
28655     } catch (std::exception& e) {
28656       {
28657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28658       };
28659     } catch (...) {
28660       {
28661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28662       };
28663     }
28664   }
28665 }
28666
28667
28668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
28669   void * jresult ;
28670   Dali::Actor arg1 ;
28671   Dali::Actor *argp1 ;
28672   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
28673
28674   argp1 = (Dali::Actor *)jarg1;
28675   if (!argp1) {
28676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28677     return 0;
28678   }
28679   arg1 = *argp1;
28680   {
28681     try {
28682       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
28683     } catch (std::out_of_range& e) {
28684       {
28685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28686       };
28687     } catch (std::exception& e) {
28688       {
28689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28690       };
28691     } catch (...) {
28692       {
28693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28694       };
28695     }
28696   }
28697   jresult = (void *)result;
28698   return jresult;
28699 }
28700
28701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28702   int jresult ;
28703   int result;
28704
28705   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28706   jresult = (int)result;
28707   return jresult;
28708 }
28709
28710
28711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28712   int jresult ;
28713   int result;
28714
28715   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28716   jresult = (int)result;
28717   return jresult;
28718 }
28719
28720
28721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28722   int jresult ;
28723   int result;
28724
28725   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28726   jresult = (int)result;
28727   return jresult;
28728 }
28729
28730
28731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28732   int jresult ;
28733   int result;
28734
28735   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28736   jresult = (int)result;
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28742   int jresult ;
28743   int result;
28744
28745   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28746   jresult = (int)result;
28747   return jresult;
28748 }
28749
28750
28751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28752   int jresult ;
28753   int result;
28754
28755   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28756   jresult = (int)result;
28757   return jresult;
28758 }
28759
28760
28761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28762   int jresult ;
28763   int result;
28764
28765   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28766   jresult = (int)result;
28767   return jresult;
28768 }
28769
28770
28771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28772   int jresult ;
28773   int result;
28774
28775   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28776   jresult = (int)result;
28777   return jresult;
28778 }
28779
28780
28781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28782   int jresult ;
28783   int result;
28784
28785   result = (int)Dali::Actor::Property::SIZE;
28786   jresult = (int)result;
28787   return jresult;
28788 }
28789
28790
28791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28792   int jresult ;
28793   int result;
28794
28795   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28796   jresult = (int)result;
28797   return jresult;
28798 }
28799
28800
28801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28802   int jresult ;
28803   int result;
28804
28805   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28806   jresult = (int)result;
28807   return jresult;
28808 }
28809
28810
28811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28812   int jresult ;
28813   int result;
28814
28815   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28816   jresult = (int)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28822   int jresult ;
28823   int result;
28824
28825   result = (int)Dali::Actor::Property::POSITION;
28826   jresult = (int)result;
28827   return jresult;
28828 }
28829
28830
28831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28832   int jresult ;
28833   int result;
28834
28835   result = (int)Dali::Actor::Property::POSITION_X;
28836   jresult = (int)result;
28837   return jresult;
28838 }
28839
28840
28841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28842   int jresult ;
28843   int result;
28844
28845   result = (int)Dali::Actor::Property::POSITION_Y;
28846   jresult = (int)result;
28847   return jresult;
28848 }
28849
28850
28851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28852   int jresult ;
28853   int result;
28854
28855   result = (int)Dali::Actor::Property::POSITION_Z;
28856   jresult = (int)result;
28857   return jresult;
28858 }
28859
28860
28861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28862   int jresult ;
28863   int result;
28864
28865   result = (int)Dali::Actor::Property::WORLD_POSITION;
28866   jresult = (int)result;
28867   return jresult;
28868 }
28869
28870
28871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28872   int jresult ;
28873   int result;
28874
28875   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28876   jresult = (int)result;
28877   return jresult;
28878 }
28879
28880
28881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28882   int jresult ;
28883   int result;
28884
28885   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28886   jresult = (int)result;
28887   return jresult;
28888 }
28889
28890
28891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28892   int jresult ;
28893   int result;
28894
28895   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28896   jresult = (int)result;
28897   return jresult;
28898 }
28899
28900
28901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28902   int jresult ;
28903   int result;
28904
28905   result = (int)Dali::Actor::Property::ORIENTATION;
28906   jresult = (int)result;
28907   return jresult;
28908 }
28909
28910
28911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28912   int jresult ;
28913   int result;
28914
28915   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28916   jresult = (int)result;
28917   return jresult;
28918 }
28919
28920
28921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28922   int jresult ;
28923   int result;
28924
28925   result = (int)Dali::Actor::Property::SCALE;
28926   jresult = (int)result;
28927   return jresult;
28928 }
28929
28930
28931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28932   int jresult ;
28933   int result;
28934
28935   result = (int)Dali::Actor::Property::SCALE_X;
28936   jresult = (int)result;
28937   return jresult;
28938 }
28939
28940
28941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28942   int jresult ;
28943   int result;
28944
28945   result = (int)Dali::Actor::Property::SCALE_Y;
28946   jresult = (int)result;
28947   return jresult;
28948 }
28949
28950
28951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28952   int jresult ;
28953   int result;
28954
28955   result = (int)Dali::Actor::Property::SCALE_Z;
28956   jresult = (int)result;
28957   return jresult;
28958 }
28959
28960
28961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28962   int jresult ;
28963   int result;
28964
28965   result = (int)Dali::Actor::Property::WORLD_SCALE;
28966   jresult = (int)result;
28967   return jresult;
28968 }
28969
28970
28971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28972   int jresult ;
28973   int result;
28974
28975   result = (int)Dali::Actor::Property::VISIBLE;
28976   jresult = (int)result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28982   int jresult ;
28983   int result;
28984
28985   result = (int)Dali::Actor::Property::COLOR;
28986   jresult = (int)result;
28987   return jresult;
28988 }
28989
28990
28991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28992   int jresult ;
28993   int result;
28994
28995   result = (int)Dali::Actor::Property::COLOR_RED;
28996   jresult = (int)result;
28997   return jresult;
28998 }
28999
29000
29001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
29002   int jresult ;
29003   int result;
29004
29005   result = (int)Dali::Actor::Property::COLOR_GREEN;
29006   jresult = (int)result;
29007   return jresult;
29008 }
29009
29010
29011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
29012   int jresult ;
29013   int result;
29014
29015   result = (int)Dali::Actor::Property::COLOR_BLUE;
29016   jresult = (int)result;
29017   return jresult;
29018 }
29019
29020
29021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
29022   int jresult ;
29023   int result;
29024
29025   result = (int)Dali::Actor::Property::COLOR_ALPHA;
29026   jresult = (int)result;
29027   return jresult;
29028 }
29029
29030
29031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
29032   int jresult ;
29033   int result;
29034
29035   result = (int)Dali::Actor::Property::WORLD_COLOR;
29036   jresult = (int)result;
29037   return jresult;
29038 }
29039
29040
29041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
29042   int jresult ;
29043   int result;
29044
29045   result = (int)Dali::Actor::Property::WORLD_MATRIX;
29046   jresult = (int)result;
29047   return jresult;
29048 }
29049
29050
29051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
29052   int jresult ;
29053   int result;
29054
29055   result = (int)Dali::Actor::Property::NAME;
29056   jresult = (int)result;
29057   return jresult;
29058 }
29059
29060
29061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
29062   int jresult ;
29063   int result;
29064
29065   result = (int)Dali::Actor::Property::SENSITIVE;
29066   jresult = (int)result;
29067   return jresult;
29068 }
29069
29070
29071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
29072   int jresult ;
29073   int result;
29074
29075   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
29076   jresult = (int)result;
29077   return jresult;
29078 }
29079
29080
29081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
29082   int jresult ;
29083   int result;
29084
29085   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
29086   jresult = (int)result;
29087   return jresult;
29088 }
29089
29090
29091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
29092   int jresult ;
29093   int result;
29094
29095   result = (int)Dali::Actor::Property::INHERIT_SCALE;
29096   jresult = (int)result;
29097   return jresult;
29098 }
29099
29100
29101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
29102   int jresult ;
29103   int result;
29104
29105   result = (int)Dali::Actor::Property::COLOR_MODE;
29106   jresult = (int)result;
29107   return jresult;
29108 }
29109
29110
29111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
29112   int jresult ;
29113   int result;
29114
29115   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
29116   jresult = (int)result;
29117   return jresult;
29118 }
29119
29120
29121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
29122   int jresult ;
29123   int result;
29124
29125   result = (int)Dali::Actor::Property::DRAW_MODE;
29126   jresult = (int)result;
29127   return jresult;
29128 }
29129
29130
29131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
29132   int jresult ;
29133   int result;
29134
29135   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
29136   jresult = (int)result;
29137   return jresult;
29138 }
29139
29140
29141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
29142   int jresult ;
29143   int result;
29144
29145   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
29146   jresult = (int)result;
29147   return jresult;
29148 }
29149
29150
29151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
29152   int jresult ;
29153   int result;
29154
29155   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
29156   jresult = (int)result;
29157   return jresult;
29158 }
29159
29160
29161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
29162   int jresult ;
29163   int result;
29164
29165   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
29166   jresult = (int)result;
29167   return jresult;
29168 }
29169
29170
29171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29172   int jresult ;
29173   int result;
29174
29175   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29176   jresult = (int)result;
29177   return jresult;
29178 }
29179
29180
29181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29182   int jresult ;
29183   int result;
29184
29185   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29186   jresult = (int)result;
29187   return jresult;
29188 }
29189
29190
29191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29192   int jresult ;
29193   int result;
29194
29195   result = (int)Dali::Actor::Property::PADDING;
29196   jresult = (int)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29202   int jresult ;
29203   int result;
29204
29205   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29206   jresult = (int)result;
29207   return jresult;
29208 }
29209
29210
29211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29212   int jresult ;
29213   int result;
29214
29215   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29216   jresult = (int)result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29222   int jresult ;
29223   int result;
29224
29225   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29226   jresult = (int)result;
29227   return jresult;
29228 }
29229
29230
29231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29232   int jresult ;
29233   int result;
29234
29235   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29236   jresult = (int)result;
29237   return jresult;
29238 }
29239
29240
29241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29242   void * jresult ;
29243   Dali::Actor::Property *result = 0 ;
29244
29245   {
29246     try {
29247       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29248     } catch (std::out_of_range& e) {
29249       {
29250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29251       };
29252     } catch (std::exception& e) {
29253       {
29254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29255       };
29256     } catch (...) {
29257       {
29258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29259       };
29260     }
29261   }
29262   jresult = (void *)result;
29263   return jresult;
29264 }
29265
29266
29267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29268   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29269
29270   arg1 = (Dali::Actor::Property *)jarg1;
29271   {
29272     try {
29273       delete arg1;
29274     } catch (std::out_of_range& e) {
29275       {
29276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29277       };
29278     } catch (std::exception& e) {
29279       {
29280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29281       };
29282     } catch (...) {
29283       {
29284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29285       };
29286     }
29287   }
29288 }
29289
29290
29291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29292   void * jresult ;
29293   Dali::Actor *result = 0 ;
29294
29295   {
29296     try {
29297       result = (Dali::Actor *)new Dali::Actor();
29298     } catch (std::out_of_range& e) {
29299       {
29300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29301       };
29302     } catch (std::exception& e) {
29303       {
29304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29305       };
29306     } catch (...) {
29307       {
29308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29309       };
29310     }
29311   }
29312   jresult = (void *)result;
29313   return jresult;
29314 }
29315
29316
29317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29318   void * jresult ;
29319   Dali::Actor result;
29320
29321   {
29322     try {
29323       result = Dali::Actor::New();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338   jresult = new Dali::Actor((const Dali::Actor &)result);
29339   return jresult;
29340 }
29341
29342
29343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29344   void * jresult ;
29345   Dali::BaseHandle arg1 ;
29346   Dali::BaseHandle *argp1 ;
29347   Dali::Actor result;
29348
29349   argp1 = (Dali::BaseHandle *)jarg1;
29350   if (!argp1) {
29351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29352     return 0;
29353   }
29354   arg1 = *argp1;
29355   {
29356     try {
29357       result = Dali::Actor::DownCast(arg1);
29358     } catch (std::out_of_range& e) {
29359       {
29360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29361       };
29362     } catch (std::exception& e) {
29363       {
29364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29365       };
29366     } catch (...) {
29367       {
29368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29369       };
29370     }
29371   }
29372   jresult = new Dali::Actor((const Dali::Actor &)result);
29373   return jresult;
29374 }
29375
29376
29377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29379
29380   arg1 = (Dali::Actor *)jarg1;
29381   {
29382     try {
29383       delete arg1;
29384     } catch (std::out_of_range& e) {
29385       {
29386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29387       };
29388     } catch (std::exception& e) {
29389       {
29390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29391       };
29392     } catch (...) {
29393       {
29394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29395       };
29396     }
29397   }
29398 }
29399
29400
29401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29402   void * jresult ;
29403   Dali::Actor *arg1 = 0 ;
29404   Dali::Actor *result = 0 ;
29405
29406   arg1 = (Dali::Actor *)jarg1;
29407   if (!arg1) {
29408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29409     return 0;
29410   }
29411   {
29412     try {
29413       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29414     } catch (std::out_of_range& e) {
29415       {
29416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29417       };
29418     } catch (std::exception& e) {
29419       {
29420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29421       };
29422     } catch (...) {
29423       {
29424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29425       };
29426     }
29427   }
29428   jresult = (void *)result;
29429   return jresult;
29430 }
29431
29432
29433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29434   void * jresult ;
29435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29436   Dali::Actor *arg2 = 0 ;
29437   Dali::Actor *result = 0 ;
29438
29439   arg1 = (Dali::Actor *)jarg1;
29440   arg2 = (Dali::Actor *)jarg2;
29441   if (!arg2) {
29442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29443     return 0;
29444   }
29445   {
29446     try {
29447       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29448     } catch (std::out_of_range& e) {
29449       {
29450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29451       };
29452     } catch (std::exception& e) {
29453       {
29454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29455       };
29456     } catch (...) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29459       };
29460     }
29461   }
29462   jresult = (void *)result;
29463   return jresult;
29464 }
29465
29466
29467 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29468   char * jresult ;
29469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29470   std::string *result = 0 ;
29471
29472   arg1 = (Dali::Actor *)jarg1;
29473   {
29474     try {
29475       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (...) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29487       };
29488     }
29489   }
29490   jresult = SWIG_csharp_string_callback(result->c_str());
29491   return jresult;
29492 }
29493
29494
29495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29497   std::string *arg2 = 0 ;
29498
29499   arg1 = (Dali::Actor *)jarg1;
29500   if (!jarg2) {
29501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29502     return ;
29503   }
29504   std::string arg2_str(jarg2);
29505   arg2 = &arg2_str;
29506   {
29507     try {
29508       (arg1)->SetName((std::string const &)*arg2);
29509     } catch (std::out_of_range& e) {
29510       {
29511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29512       };
29513     } catch (std::exception& e) {
29514       {
29515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29516       };
29517     } catch (...) {
29518       {
29519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29520       };
29521     }
29522   }
29523
29524   //argout typemap for const std::string&
29525
29526 }
29527
29528
29529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29530   unsigned int jresult ;
29531   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29532   unsigned int result;
29533
29534   arg1 = (Dali::Actor *)jarg1;
29535   {
29536     try {
29537       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29538     } catch (std::out_of_range& e) {
29539       {
29540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (std::exception& e) {
29543       {
29544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (...) {
29547       {
29548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29549       };
29550     }
29551   }
29552   jresult = result;
29553   return jresult;
29554 }
29555
29556
29557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29558   unsigned int jresult ;
29559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29560   bool result;
29561
29562   arg1 = (Dali::Actor *)jarg1;
29563   {
29564     try {
29565       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29566     } catch (std::out_of_range& e) {
29567       {
29568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29569       };
29570     } catch (std::exception& e) {
29571       {
29572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29577       };
29578     }
29579   }
29580   jresult = result;
29581   return jresult;
29582 }
29583
29584
29585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29586   unsigned int jresult ;
29587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29588   bool result;
29589
29590   arg1 = (Dali::Actor *)jarg1;
29591   {
29592     try {
29593       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29594     } catch (std::out_of_range& e) {
29595       {
29596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29597       };
29598     } catch (std::exception& e) {
29599       {
29600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29601       };
29602     } catch (...) {
29603       {
29604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29605       };
29606     }
29607   }
29608   jresult = result;
29609   return jresult;
29610 }
29611
29612
29613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29614   unsigned int jresult ;
29615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29616   bool result;
29617
29618   arg1 = (Dali::Actor *)jarg1;
29619   {
29620     try {
29621       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29622     } catch (std::out_of_range& e) {
29623       {
29624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29625       };
29626     } catch (std::exception& e) {
29627       {
29628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29629       };
29630     } catch (...) {
29631       {
29632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29633       };
29634     }
29635   }
29636   jresult = result;
29637   return jresult;
29638 }
29639
29640
29641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29642   void * jresult ;
29643   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29644   Dali::Layer result;
29645
29646   arg1 = (Dali::Actor *)jarg1;
29647   {
29648     try {
29649       result = (arg1)->GetLayer();
29650     } catch (std::out_of_range& e) {
29651       {
29652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29653       };
29654     } catch (std::exception& e) {
29655       {
29656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29657       };
29658     } catch (...) {
29659       {
29660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29661       };
29662     }
29663   }
29664   jresult = new Dali::Layer((const Dali::Layer &)result);
29665   return jresult;
29666 }
29667
29668
29669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29671   Dali::Actor arg2 ;
29672   Dali::Actor *argp2 ;
29673
29674   arg1 = (Dali::Actor *)jarg1;
29675   argp2 = (Dali::Actor *)jarg2;
29676   if (!argp2) {
29677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29678     return ;
29679   }
29680   arg2 = *argp2;
29681   {
29682     try {
29683       (arg1)->Add(arg2);
29684     } catch (std::out_of_range& e) {
29685       {
29686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29687       };
29688     } catch (std::exception& e) {
29689       {
29690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29691       };
29692     } catch (...) {
29693       {
29694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29695       };
29696     }
29697   }
29698 }
29699
29700
29701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29703   Dali::Actor arg2 ;
29704   Dali::Actor *argp2 ;
29705
29706   arg1 = (Dali::Actor *)jarg1;
29707   argp2 = (Dali::Actor *)jarg2;
29708   if (!argp2) {
29709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29710     return ;
29711   }
29712   arg2 = *argp2;
29713   {
29714     try {
29715       (arg1)->Remove(arg2);
29716     } catch (std::out_of_range& e) {
29717       {
29718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29719       };
29720     } catch (std::exception& e) {
29721       {
29722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29723       };
29724     } catch (...) {
29725       {
29726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29727       };
29728     }
29729   }
29730 }
29731
29732
29733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29735
29736   arg1 = (Dali::Actor *)jarg1;
29737   {
29738     try {
29739       (arg1)->Unparent();
29740     } catch (std::out_of_range& e) {
29741       {
29742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29743       };
29744     } catch (std::exception& e) {
29745       {
29746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29747       };
29748     } catch (...) {
29749       {
29750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29751       };
29752     }
29753   }
29754 }
29755
29756
29757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29758   unsigned int jresult ;
29759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29760   unsigned int result;
29761
29762   arg1 = (Dali::Actor *)jarg1;
29763   {
29764     try {
29765       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29766     } catch (std::out_of_range& e) {
29767       {
29768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29769       };
29770     } catch (std::exception& e) {
29771       {
29772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29773       };
29774     } catch (...) {
29775       {
29776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29777       };
29778     }
29779   }
29780   jresult = result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29786   void * jresult ;
29787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29788   unsigned int arg2 ;
29789   Dali::Actor result;
29790
29791   arg1 = (Dali::Actor *)jarg1;
29792   arg2 = (unsigned int)jarg2;
29793   {
29794     try {
29795       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29796     } catch (std::out_of_range& e) {
29797       {
29798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (std::exception& e) {
29801       {
29802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810   jresult = new Dali::Actor((const Dali::Actor &)result);
29811   return jresult;
29812 }
29813
29814
29815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29816   void * jresult ;
29817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29818   std::string *arg2 = 0 ;
29819   Dali::Actor result;
29820
29821   arg1 = (Dali::Actor *)jarg1;
29822   if (!jarg2) {
29823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29824     return 0;
29825   }
29826   std::string arg2_str(jarg2);
29827   arg2 = &arg2_str;
29828   {
29829     try {
29830       result = (arg1)->FindChildByName((std::string const &)*arg2);
29831     } catch (std::out_of_range& e) {
29832       {
29833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29834       };
29835     } catch (std::exception& e) {
29836       {
29837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29838       };
29839     } catch (...) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29842       };
29843     }
29844   }
29845   jresult = new Dali::Actor((const Dali::Actor &)result);
29846
29847   //argout typemap for const std::string&
29848
29849   return jresult;
29850 }
29851
29852
29853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29854   void * jresult ;
29855   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29856   unsigned int arg2 ;
29857   Dali::Actor result;
29858
29859   arg1 = (Dali::Actor *)jarg1;
29860   arg2 = (unsigned int)jarg2;
29861   {
29862     try {
29863       result = (arg1)->FindChildById(arg2);
29864     } catch (std::out_of_range& e) {
29865       {
29866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (std::exception& e) {
29869       {
29870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878   jresult = new Dali::Actor((const Dali::Actor &)result);
29879   return jresult;
29880 }
29881
29882
29883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29884   void * jresult ;
29885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29886   Dali::Actor result;
29887
29888   arg1 = (Dali::Actor *)jarg1;
29889   {
29890     try {
29891       result = ((Dali::Actor const *)arg1)->GetParent();
29892     } catch (std::out_of_range& e) {
29893       {
29894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29895       };
29896     } catch (std::exception& e) {
29897       {
29898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29899       };
29900     } catch (...) {
29901       {
29902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29903       };
29904     }
29905   }
29906   jresult = new Dali::Actor((const Dali::Actor &)result);
29907   return jresult;
29908 }
29909
29910
29911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29912   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29913   Dali::Vector3 *arg2 = 0 ;
29914
29915   arg1 = (Dali::Actor *)jarg1;
29916   arg2 = (Dali::Vector3 *)jarg2;
29917   if (!arg2) {
29918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29919     return ;
29920   }
29921   {
29922     try {
29923       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29924     } catch (std::out_of_range& e) {
29925       {
29926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29927       };
29928     } catch (std::exception& e) {
29929       {
29930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29931       };
29932     } catch (...) {
29933       {
29934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29935       };
29936     }
29937   }
29938 }
29939
29940
29941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29942   void * jresult ;
29943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29944   Dali::Vector3 result;
29945
29946   arg1 = (Dali::Actor *)jarg1;
29947   {
29948     try {
29949       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29950     } catch (std::out_of_range& e) {
29951       {
29952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (std::exception& e) {
29955       {
29956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29957       };
29958     } catch (...) {
29959       {
29960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29961       };
29962     }
29963   }
29964   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29965   return jresult;
29966 }
29967
29968
29969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29971   Dali::Vector3 *arg2 = 0 ;
29972
29973   arg1 = (Dali::Actor *)jarg1;
29974   arg2 = (Dali::Vector3 *)jarg2;
29975   if (!arg2) {
29976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29977     return ;
29978   }
29979   {
29980     try {
29981       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29982     } catch (std::out_of_range& e) {
29983       {
29984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29985       };
29986     } catch (std::exception& e) {
29987       {
29988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29989       };
29990     } catch (...) {
29991       {
29992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29993       };
29994     }
29995   }
29996 }
29997
29998
29999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
30000   void * jresult ;
30001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30002   Dali::Vector3 result;
30003
30004   arg1 = (Dali::Actor *)jarg1;
30005   {
30006     try {
30007       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
30008     } catch (std::out_of_range& e) {
30009       {
30010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30011       };
30012     } catch (std::exception& e) {
30013       {
30014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (...) {
30017       {
30018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30019       };
30020     }
30021   }
30022   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30023   return jresult;
30024 }
30025
30026
30027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30029   float arg2 ;
30030   float arg3 ;
30031
30032   arg1 = (Dali::Actor *)jarg1;
30033   arg2 = (float)jarg2;
30034   arg3 = (float)jarg3;
30035   {
30036     try {
30037       (arg1)->SetSize(arg2,arg3);
30038     } catch (std::out_of_range& e) {
30039       {
30040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30041       };
30042     } catch (std::exception& e) {
30043       {
30044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30045       };
30046     } catch (...) {
30047       {
30048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30049       };
30050     }
30051   }
30052 }
30053
30054
30055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30056   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30057   float arg2 ;
30058   float arg3 ;
30059   float arg4 ;
30060
30061   arg1 = (Dali::Actor *)jarg1;
30062   arg2 = (float)jarg2;
30063   arg3 = (float)jarg3;
30064   arg4 = (float)jarg4;
30065   {
30066     try {
30067       (arg1)->SetSize(arg2,arg3,arg4);
30068     } catch (std::out_of_range& e) {
30069       {
30070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30071       };
30072     } catch (std::exception& e) {
30073       {
30074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30075       };
30076     } catch (...) {
30077       {
30078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30079       };
30080     }
30081   }
30082 }
30083
30084
30085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
30086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30087   Dali::Vector2 *arg2 = 0 ;
30088
30089   arg1 = (Dali::Actor *)jarg1;
30090   arg2 = (Dali::Vector2 *)jarg2;
30091   if (!arg2) {
30092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
30093     return ;
30094   }
30095   {
30096     try {
30097       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
30098     } catch (std::out_of_range& e) {
30099       {
30100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30101       };
30102     } catch (std::exception& e) {
30103       {
30104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30105       };
30106     } catch (...) {
30107       {
30108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30109       };
30110     }
30111   }
30112 }
30113
30114
30115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
30116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30117   Dali::Vector3 *arg2 = 0 ;
30118
30119   arg1 = (Dali::Actor *)jarg1;
30120   arg2 = (Dali::Vector3 *)jarg2;
30121   if (!arg2) {
30122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30123     return ;
30124   }
30125   {
30126     try {
30127       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
30128     } catch (std::out_of_range& e) {
30129       {
30130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30131       };
30132     } catch (std::exception& e) {
30133       {
30134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30135       };
30136     } catch (...) {
30137       {
30138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30139       };
30140     }
30141   }
30142 }
30143
30144
30145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
30146   void * jresult ;
30147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30148   Dali::Vector3 result;
30149
30150   arg1 = (Dali::Actor *)jarg1;
30151   {
30152     try {
30153       result = ((Dali::Actor const *)arg1)->GetTargetSize();
30154     } catch (std::out_of_range& e) {
30155       {
30156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30157       };
30158     } catch (std::exception& e) {
30159       {
30160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30161       };
30162     } catch (...) {
30163       {
30164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30165       };
30166     }
30167   }
30168   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30174   void * jresult ;
30175   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30176   Dali::Vector3 result;
30177
30178   arg1 = (Dali::Actor *)jarg1;
30179   {
30180     try {
30181       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30182     } catch (std::out_of_range& e) {
30183       {
30184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30185       };
30186     } catch (std::exception& e) {
30187       {
30188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30189       };
30190     } catch (...) {
30191       {
30192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30193       };
30194     }
30195   }
30196   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30197   return jresult;
30198 }
30199
30200
30201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30202   void * jresult ;
30203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30204   Dali::Vector3 result;
30205
30206   arg1 = (Dali::Actor *)jarg1;
30207   {
30208     try {
30209       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30210     } catch (std::out_of_range& e) {
30211       {
30212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (std::exception& e) {
30215       {
30216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30225   return jresult;
30226 }
30227
30228
30229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30231   float arg2 ;
30232   float arg3 ;
30233
30234   arg1 = (Dali::Actor *)jarg1;
30235   arg2 = (float)jarg2;
30236   arg3 = (float)jarg3;
30237   {
30238     try {
30239       (arg1)->SetPosition(arg2,arg3);
30240     } catch (std::out_of_range& e) {
30241       {
30242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30243       };
30244     } catch (std::exception& e) {
30245       {
30246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30247       };
30248     } catch (...) {
30249       {
30250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30251       };
30252     }
30253   }
30254 }
30255
30256
30257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30259   float arg2 ;
30260   float arg3 ;
30261   float arg4 ;
30262
30263   arg1 = (Dali::Actor *)jarg1;
30264   arg2 = (float)jarg2;
30265   arg3 = (float)jarg3;
30266   arg4 = (float)jarg4;
30267   {
30268     try {
30269       (arg1)->SetPosition(arg2,arg3,arg4);
30270     } catch (std::out_of_range& e) {
30271       {
30272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30273       };
30274     } catch (std::exception& e) {
30275       {
30276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30277       };
30278     } catch (...) {
30279       {
30280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30281       };
30282     }
30283   }
30284 }
30285
30286
30287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30289   Dali::Vector3 *arg2 = 0 ;
30290
30291   arg1 = (Dali::Actor *)jarg1;
30292   arg2 = (Dali::Vector3 *)jarg2;
30293   if (!arg2) {
30294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30295     return ;
30296   }
30297   {
30298     try {
30299       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30300     } catch (std::out_of_range& e) {
30301       {
30302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30303       };
30304     } catch (std::exception& e) {
30305       {
30306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30307       };
30308     } catch (...) {
30309       {
30310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30311       };
30312     }
30313   }
30314 }
30315
30316
30317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30319   float arg2 ;
30320
30321   arg1 = (Dali::Actor *)jarg1;
30322   arg2 = (float)jarg2;
30323   {
30324     try {
30325       (arg1)->SetX(arg2);
30326     } catch (std::out_of_range& e) {
30327       {
30328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30329       };
30330     } catch (std::exception& e) {
30331       {
30332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30333       };
30334     } catch (...) {
30335       {
30336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30337       };
30338     }
30339   }
30340 }
30341
30342
30343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30345   float arg2 ;
30346
30347   arg1 = (Dali::Actor *)jarg1;
30348   arg2 = (float)jarg2;
30349   {
30350     try {
30351       (arg1)->SetY(arg2);
30352     } catch (std::out_of_range& e) {
30353       {
30354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (std::exception& e) {
30357       {
30358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30371   float arg2 ;
30372
30373   arg1 = (Dali::Actor *)jarg1;
30374   arg2 = (float)jarg2;
30375   {
30376     try {
30377       (arg1)->SetZ(arg2);
30378     } catch (std::out_of_range& e) {
30379       {
30380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30381       };
30382     } catch (std::exception& e) {
30383       {
30384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30385       };
30386     } catch (...) {
30387       {
30388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30389       };
30390     }
30391   }
30392 }
30393
30394
30395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30397   Dali::Vector3 *arg2 = 0 ;
30398
30399   arg1 = (Dali::Actor *)jarg1;
30400   arg2 = (Dali::Vector3 *)jarg2;
30401   if (!arg2) {
30402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30403     return ;
30404   }
30405   {
30406     try {
30407       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30408     } catch (std::out_of_range& e) {
30409       {
30410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30411       };
30412     } catch (std::exception& e) {
30413       {
30414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30415       };
30416     } catch (...) {
30417       {
30418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30419       };
30420     }
30421   }
30422 }
30423
30424
30425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30426   void * jresult ;
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   Dali::Vector3 result;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   {
30432     try {
30433       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30434     } catch (std::out_of_range& e) {
30435       {
30436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30437       };
30438     } catch (std::exception& e) {
30439       {
30440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30441       };
30442     } catch (...) {
30443       {
30444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30445       };
30446     }
30447   }
30448   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30449   return jresult;
30450 }
30451
30452
30453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30454   void * jresult ;
30455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30456   Dali::Vector3 result;
30457
30458   arg1 = (Dali::Actor *)jarg1;
30459   {
30460     try {
30461       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30462     } catch (std::out_of_range& e) {
30463       {
30464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30465       };
30466     } catch (std::exception& e) {
30467       {
30468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30469       };
30470     } catch (...) {
30471       {
30472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30473       };
30474     }
30475   }
30476   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30477   return jresult;
30478 }
30479
30480
30481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30483   bool arg2 ;
30484
30485   arg1 = (Dali::Actor *)jarg1;
30486   arg2 = jarg2 ? true : false;
30487   {
30488     try {
30489       (arg1)->SetInheritPosition(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (...) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30501       };
30502     }
30503   }
30504 }
30505
30506
30507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30508   int jresult ;
30509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30510   Dali::PositionInheritanceMode result;
30511
30512   arg1 = (Dali::Actor *)jarg1;
30513   {
30514     try {
30515       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30516     } catch (std::out_of_range& e) {
30517       {
30518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30519       };
30520     } catch (std::exception& e) {
30521       {
30522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30523       };
30524     } catch (...) {
30525       {
30526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30527       };
30528     }
30529   }
30530   jresult = (int)result;
30531   return jresult;
30532 }
30533
30534
30535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30536   unsigned int jresult ;
30537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30538   bool result;
30539
30540   arg1 = (Dali::Actor *)jarg1;
30541   {
30542     try {
30543       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30544     } catch (std::out_of_range& e) {
30545       {
30546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30547       };
30548     } catch (std::exception& e) {
30549       {
30550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30551       };
30552     } catch (...) {
30553       {
30554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30555       };
30556     }
30557   }
30558   jresult = result;
30559   return jresult;
30560 }
30561
30562
30563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30565   Dali::Degree *arg2 = 0 ;
30566   Dali::Vector3 *arg3 = 0 ;
30567
30568   arg1 = (Dali::Actor *)jarg1;
30569   arg2 = (Dali::Degree *)jarg2;
30570   if (!arg2) {
30571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30572     return ;
30573   }
30574   arg3 = (Dali::Vector3 *)jarg3;
30575   if (!arg3) {
30576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30577     return ;
30578   }
30579   {
30580     try {
30581       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30582     } catch (std::out_of_range& e) {
30583       {
30584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30585       };
30586     } catch (std::exception& e) {
30587       {
30588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30589       };
30590     } catch (...) {
30591       {
30592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30593       };
30594     }
30595   }
30596 }
30597
30598
30599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30600   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30601   Dali::Radian *arg2 = 0 ;
30602   Dali::Vector3 *arg3 = 0 ;
30603
30604   arg1 = (Dali::Actor *)jarg1;
30605   arg2 = (Dali::Radian *)jarg2;
30606   if (!arg2) {
30607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30608     return ;
30609   }
30610   arg3 = (Dali::Vector3 *)jarg3;
30611   if (!arg3) {
30612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30613     return ;
30614   }
30615   {
30616     try {
30617       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30618     } catch (std::out_of_range& e) {
30619       {
30620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30621       };
30622     } catch (std::exception& e) {
30623       {
30624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30625       };
30626     } catch (...) {
30627       {
30628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30629       };
30630     }
30631   }
30632 }
30633
30634
30635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30637   Dali::Quaternion *arg2 = 0 ;
30638
30639   arg1 = (Dali::Actor *)jarg1;
30640   arg2 = (Dali::Quaternion *)jarg2;
30641   if (!arg2) {
30642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30643     return ;
30644   }
30645   {
30646     try {
30647       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30648     } catch (std::out_of_range& e) {
30649       {
30650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30651       };
30652     } catch (std::exception& e) {
30653       {
30654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30655       };
30656     } catch (...) {
30657       {
30658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30659       };
30660     }
30661   }
30662 }
30663
30664
30665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30667   Dali::Degree *arg2 = 0 ;
30668   Dali::Vector3 *arg3 = 0 ;
30669
30670   arg1 = (Dali::Actor *)jarg1;
30671   arg2 = (Dali::Degree *)jarg2;
30672   if (!arg2) {
30673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30674     return ;
30675   }
30676   arg3 = (Dali::Vector3 *)jarg3;
30677   if (!arg3) {
30678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30679     return ;
30680   }
30681   {
30682     try {
30683       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30684     } catch (std::out_of_range& e) {
30685       {
30686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30687       };
30688     } catch (std::exception& e) {
30689       {
30690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30691       };
30692     } catch (...) {
30693       {
30694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30695       };
30696     }
30697   }
30698 }
30699
30700
30701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30703   Dali::Radian *arg2 = 0 ;
30704   Dali::Vector3 *arg3 = 0 ;
30705
30706   arg1 = (Dali::Actor *)jarg1;
30707   arg2 = (Dali::Radian *)jarg2;
30708   if (!arg2) {
30709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30710     return ;
30711   }
30712   arg3 = (Dali::Vector3 *)jarg3;
30713   if (!arg3) {
30714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30715     return ;
30716   }
30717   {
30718     try {
30719       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30720     } catch (std::out_of_range& e) {
30721       {
30722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30723       };
30724     } catch (std::exception& e) {
30725       {
30726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30727       };
30728     } catch (...) {
30729       {
30730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30731       };
30732     }
30733   }
30734 }
30735
30736
30737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30738   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30739   Dali::Quaternion *arg2 = 0 ;
30740
30741   arg1 = (Dali::Actor *)jarg1;
30742   arg2 = (Dali::Quaternion *)jarg2;
30743   if (!arg2) {
30744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30745     return ;
30746   }
30747   {
30748     try {
30749       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30750     } catch (std::out_of_range& e) {
30751       {
30752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30753       };
30754     } catch (std::exception& e) {
30755       {
30756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30757       };
30758     } catch (...) {
30759       {
30760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30761       };
30762     }
30763   }
30764 }
30765
30766
30767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30768   void * jresult ;
30769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30770   Dali::Quaternion result;
30771
30772   arg1 = (Dali::Actor *)jarg1;
30773   {
30774     try {
30775       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30776     } catch (std::out_of_range& e) {
30777       {
30778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30779       };
30780     } catch (std::exception& e) {
30781       {
30782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30783       };
30784     } catch (...) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30787       };
30788     }
30789   }
30790   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30797   bool arg2 ;
30798
30799   arg1 = (Dali::Actor *)jarg1;
30800   arg2 = jarg2 ? true : false;
30801   {
30802     try {
30803       (arg1)->SetInheritOrientation(arg2);
30804     } catch (std::out_of_range& e) {
30805       {
30806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30807       };
30808     } catch (std::exception& e) {
30809       {
30810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30815       };
30816     }
30817   }
30818 }
30819
30820
30821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30822   unsigned int jresult ;
30823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30824   bool result;
30825
30826   arg1 = (Dali::Actor *)jarg1;
30827   {
30828     try {
30829       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30830     } catch (std::out_of_range& e) {
30831       {
30832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30833       };
30834     } catch (std::exception& e) {
30835       {
30836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30837       };
30838     } catch (...) {
30839       {
30840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30841       };
30842     }
30843   }
30844   jresult = result;
30845   return jresult;
30846 }
30847
30848
30849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30850   void * jresult ;
30851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30852   Dali::Quaternion result;
30853
30854   arg1 = (Dali::Actor *)jarg1;
30855   {
30856     try {
30857       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30858     } catch (std::out_of_range& e) {
30859       {
30860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30861       };
30862     } catch (std::exception& e) {
30863       {
30864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30865       };
30866     } catch (...) {
30867       {
30868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30869       };
30870     }
30871   }
30872   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30873   return jresult;
30874 }
30875
30876
30877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30879   float arg2 ;
30880
30881   arg1 = (Dali::Actor *)jarg1;
30882   arg2 = (float)jarg2;
30883   {
30884     try {
30885       (arg1)->SetScale(arg2);
30886     } catch (std::out_of_range& e) {
30887       {
30888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30889       };
30890     } catch (std::exception& e) {
30891       {
30892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30893       };
30894     } catch (...) {
30895       {
30896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30897       };
30898     }
30899   }
30900 }
30901
30902
30903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30905   float arg2 ;
30906   float arg3 ;
30907   float arg4 ;
30908
30909   arg1 = (Dali::Actor *)jarg1;
30910   arg2 = (float)jarg2;
30911   arg3 = (float)jarg3;
30912   arg4 = (float)jarg4;
30913   {
30914     try {
30915       (arg1)->SetScale(arg2,arg3,arg4);
30916     } catch (std::out_of_range& e) {
30917       {
30918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30919       };
30920     } catch (std::exception& e) {
30921       {
30922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30923       };
30924     } catch (...) {
30925       {
30926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30927       };
30928     }
30929   }
30930 }
30931
30932
30933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30935   Dali::Vector3 *arg2 = 0 ;
30936
30937   arg1 = (Dali::Actor *)jarg1;
30938   arg2 = (Dali::Vector3 *)jarg2;
30939   if (!arg2) {
30940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30941     return ;
30942   }
30943   {
30944     try {
30945       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30946     } catch (std::out_of_range& e) {
30947       {
30948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30949       };
30950     } catch (std::exception& e) {
30951       {
30952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30953       };
30954     } catch (...) {
30955       {
30956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30957       };
30958     }
30959   }
30960 }
30961
30962
30963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30965   Dali::Vector3 *arg2 = 0 ;
30966
30967   arg1 = (Dali::Actor *)jarg1;
30968   arg2 = (Dali::Vector3 *)jarg2;
30969   if (!arg2) {
30970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30971     return ;
30972   }
30973   {
30974     try {
30975       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30987       };
30988     }
30989   }
30990 }
30991
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30994   void * jresult ;
30995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30996   Dali::Vector3 result;
30997
30998   arg1 = (Dali::Actor *)jarg1;
30999   {
31000     try {
31001       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
31002     } catch (std::out_of_range& e) {
31003       {
31004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (std::exception& e) {
31007       {
31008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31017   return jresult;
31018 }
31019
31020
31021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
31022   void * jresult ;
31023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31024   Dali::Vector3 result;
31025
31026   arg1 = (Dali::Actor *)jarg1;
31027   {
31028     try {
31029       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (...) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31041       };
31042     }
31043   }
31044   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31045   return jresult;
31046 }
31047
31048
31049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
31050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31051   bool arg2 ;
31052
31053   arg1 = (Dali::Actor *)jarg1;
31054   arg2 = jarg2 ? true : false;
31055   {
31056     try {
31057       (arg1)->SetInheritScale(arg2);
31058     } catch (std::out_of_range& e) {
31059       {
31060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31061       };
31062     } catch (std::exception& e) {
31063       {
31064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31065       };
31066     } catch (...) {
31067       {
31068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31069       };
31070     }
31071   }
31072 }
31073
31074
31075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
31076   unsigned int jresult ;
31077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31078   bool result;
31079
31080   arg1 = (Dali::Actor *)jarg1;
31081   {
31082     try {
31083       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (...) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31095       };
31096     }
31097   }
31098   jresult = result;
31099   return jresult;
31100 }
31101
31102
31103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
31104   void * jresult ;
31105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31106   Dali::Matrix result;
31107
31108   arg1 = (Dali::Actor *)jarg1;
31109   {
31110     try {
31111       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
31112     } catch (std::out_of_range& e) {
31113       {
31114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31115       };
31116     } catch (std::exception& e) {
31117       {
31118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31119       };
31120     } catch (...) {
31121       {
31122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31123       };
31124     }
31125   }
31126   jresult = new Dali::Matrix((const Dali::Matrix &)result);
31127   return jresult;
31128 }
31129
31130
31131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
31132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31133   bool arg2 ;
31134
31135   arg1 = (Dali::Actor *)jarg1;
31136   arg2 = jarg2 ? true : false;
31137   {
31138     try {
31139       (arg1)->SetVisible(arg2);
31140     } catch (std::out_of_range& e) {
31141       {
31142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31143       };
31144     } catch (std::exception& e) {
31145       {
31146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31147       };
31148     } catch (...) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31151       };
31152     }
31153   }
31154 }
31155
31156
31157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
31158   unsigned int jresult ;
31159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31160   bool result;
31161
31162   arg1 = (Dali::Actor *)jarg1;
31163   {
31164     try {
31165       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
31166     } catch (std::out_of_range& e) {
31167       {
31168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31169       };
31170     } catch (std::exception& e) {
31171       {
31172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31173       };
31174     } catch (...) {
31175       {
31176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31177       };
31178     }
31179   }
31180   jresult = result;
31181   return jresult;
31182 }
31183
31184
31185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31187   float arg2 ;
31188
31189   arg1 = (Dali::Actor *)jarg1;
31190   arg2 = (float)jarg2;
31191   {
31192     try {
31193       (arg1)->SetOpacity(arg2);
31194     } catch (std::out_of_range& e) {
31195       {
31196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31197       };
31198     } catch (std::exception& e) {
31199       {
31200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31201       };
31202     } catch (...) {
31203       {
31204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31205       };
31206     }
31207   }
31208 }
31209
31210
31211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31212   float jresult ;
31213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31214   float result;
31215
31216   arg1 = (Dali::Actor *)jarg1;
31217   {
31218     try {
31219       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31220     } catch (std::out_of_range& e) {
31221       {
31222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31223       };
31224     } catch (std::exception& e) {
31225       {
31226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31227       };
31228     } catch (...) {
31229       {
31230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31231       };
31232     }
31233   }
31234   jresult = result;
31235   return jresult;
31236 }
31237
31238
31239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31241   Dali::Vector4 *arg2 = 0 ;
31242
31243   arg1 = (Dali::Actor *)jarg1;
31244   arg2 = (Dali::Vector4 *)jarg2;
31245   if (!arg2) {
31246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31247     return ;
31248   }
31249   {
31250     try {
31251       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31252     } catch (std::out_of_range& e) {
31253       {
31254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31255       };
31256     } catch (std::exception& e) {
31257       {
31258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31259       };
31260     } catch (...) {
31261       {
31262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31263       };
31264     }
31265   }
31266 }
31267
31268
31269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31270   void * jresult ;
31271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31272   Dali::Vector4 result;
31273
31274   arg1 = (Dali::Actor *)jarg1;
31275   {
31276     try {
31277       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31278     } catch (std::out_of_range& e) {
31279       {
31280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31281       };
31282     } catch (std::exception& e) {
31283       {
31284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31285       };
31286     } catch (...) {
31287       {
31288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31289       };
31290     }
31291   }
31292   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31293   return jresult;
31294 }
31295
31296
31297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31299   Dali::ColorMode arg2 ;
31300
31301   arg1 = (Dali::Actor *)jarg1;
31302   arg2 = (Dali::ColorMode)jarg2;
31303   {
31304     try {
31305       (arg1)->SetColorMode(arg2);
31306     } catch (std::out_of_range& e) {
31307       {
31308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31309       };
31310     } catch (std::exception& e) {
31311       {
31312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31313       };
31314     } catch (...) {
31315       {
31316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31317       };
31318     }
31319   }
31320 }
31321
31322
31323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31324   int jresult ;
31325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31326   Dali::ColorMode result;
31327
31328   arg1 = (Dali::Actor *)jarg1;
31329   {
31330     try {
31331       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31332     } catch (std::out_of_range& e) {
31333       {
31334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31335       };
31336     } catch (std::exception& e) {
31337       {
31338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31339       };
31340     } catch (...) {
31341       {
31342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31343       };
31344     }
31345   }
31346   jresult = (int)result;
31347   return jresult;
31348 }
31349
31350
31351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31352   void * jresult ;
31353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31354   Dali::Vector4 result;
31355
31356   arg1 = (Dali::Actor *)jarg1;
31357   {
31358     try {
31359       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31360     } catch (std::out_of_range& e) {
31361       {
31362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31363       };
31364     } catch (std::exception& e) {
31365       {
31366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31367       };
31368     } catch (...) {
31369       {
31370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31371       };
31372     }
31373   }
31374   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31375   return jresult;
31376 }
31377
31378
31379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31381   Dali::DrawMode::Type arg2 ;
31382
31383   arg1 = (Dali::Actor *)jarg1;
31384   arg2 = (Dali::DrawMode::Type)jarg2;
31385   {
31386     try {
31387       (arg1)->SetDrawMode(arg2);
31388     } catch (std::out_of_range& e) {
31389       {
31390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31391       };
31392     } catch (std::exception& e) {
31393       {
31394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31395       };
31396     } catch (...) {
31397       {
31398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31399       };
31400     }
31401   }
31402 }
31403
31404
31405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31406   int jresult ;
31407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31408   Dali::DrawMode::Type result;
31409
31410   arg1 = (Dali::Actor *)jarg1;
31411   {
31412     try {
31413       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31414     } catch (std::out_of_range& e) {
31415       {
31416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31417       };
31418     } catch (std::exception& e) {
31419       {
31420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31421       };
31422     } catch (...) {
31423       {
31424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31425       };
31426     }
31427   }
31428   jresult = (int)result;
31429   return jresult;
31430 }
31431
31432
31433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31435   bool arg2 ;
31436
31437   arg1 = (Dali::Actor *)jarg1;
31438   arg2 = jarg2 ? true : false;
31439   {
31440     try {
31441       (arg1)->SetSensitive(arg2);
31442     } catch (std::out_of_range& e) {
31443       {
31444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31445       };
31446     } catch (std::exception& e) {
31447       {
31448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31449       };
31450     } catch (...) {
31451       {
31452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31453       };
31454     }
31455   }
31456 }
31457
31458
31459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31460   unsigned int jresult ;
31461   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31462   bool result;
31463
31464   arg1 = (Dali::Actor *)jarg1;
31465   {
31466     try {
31467       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31468     } catch (std::out_of_range& e) {
31469       {
31470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31471       };
31472     } catch (std::exception& e) {
31473       {
31474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31475       };
31476     } catch (...) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31479       };
31480     }
31481   }
31482   jresult = result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31488   unsigned int jresult ;
31489   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31490   float *arg2 = 0 ;
31491   float *arg3 = 0 ;
31492   float arg4 ;
31493   float arg5 ;
31494   bool result;
31495
31496   arg1 = (Dali::Actor *)jarg1;
31497   arg2 = (float *)jarg2;
31498   arg3 = (float *)jarg3;
31499   arg4 = (float)jarg4;
31500   arg5 = (float)jarg5;
31501   {
31502     try {
31503       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31504     } catch (std::out_of_range& e) {
31505       {
31506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31507       };
31508     } catch (std::exception& e) {
31509       {
31510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31511       };
31512     } catch (...) {
31513       {
31514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31515       };
31516     }
31517   }
31518   jresult = result;
31519   return jresult;
31520 }
31521
31522
31523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31525   bool arg2 ;
31526
31527   arg1 = (Dali::Actor *)jarg1;
31528   arg2 = jarg2 ? true : false;
31529   {
31530     try {
31531       (arg1)->SetLeaveRequired(arg2);
31532     } catch (std::out_of_range& e) {
31533       {
31534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31535       };
31536     } catch (std::exception& e) {
31537       {
31538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31539       };
31540     } catch (...) {
31541       {
31542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31543       };
31544     }
31545   }
31546 }
31547
31548
31549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31550   unsigned int jresult ;
31551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31552   bool result;
31553
31554   arg1 = (Dali::Actor *)jarg1;
31555   {
31556     try {
31557       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31558     } catch (std::out_of_range& e) {
31559       {
31560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31561       };
31562     } catch (std::exception& e) {
31563       {
31564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31565       };
31566     } catch (...) {
31567       {
31568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31569       };
31570     }
31571   }
31572   jresult = result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31579   bool arg2 ;
31580
31581   arg1 = (Dali::Actor *)jarg1;
31582   arg2 = jarg2 ? true : false;
31583   {
31584     try {
31585       (arg1)->SetKeyboardFocusable(arg2);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31593       };
31594     } catch (...) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31597       };
31598     }
31599   }
31600 }
31601
31602
31603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31604   unsigned int jresult ;
31605   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31606   bool result;
31607
31608   arg1 = (Dali::Actor *)jarg1;
31609   {
31610     try {
31611       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31612     } catch (std::out_of_range& e) {
31613       {
31614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31615       };
31616     } catch (std::exception& e) {
31617       {
31618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31619       };
31620     } catch (...) {
31621       {
31622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31623       };
31624     }
31625   }
31626   jresult = result;
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31633   Dali::ResizePolicy::Type arg2 ;
31634   Dali::Dimension::Type arg3 ;
31635
31636   arg1 = (Dali::Actor *)jarg1;
31637   arg2 = (Dali::ResizePolicy::Type)jarg2;
31638   arg3 = (Dali::Dimension::Type)jarg3;
31639   {
31640     try {
31641       (arg1)->SetResizePolicy(arg2,arg3);
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31649       };
31650     } catch (...) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31653       };
31654     }
31655   }
31656 }
31657
31658
31659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31660   int jresult ;
31661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31662   Dali::Dimension::Type arg2 ;
31663   Dali::ResizePolicy::Type result;
31664
31665   arg1 = (Dali::Actor *)jarg1;
31666   arg2 = (Dali::Dimension::Type)jarg2;
31667   {
31668     try {
31669       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31670     } catch (std::out_of_range& e) {
31671       {
31672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (std::exception& e) {
31675       {
31676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684   jresult = (int)result;
31685   return jresult;
31686 }
31687
31688
31689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31691   Dali::SizeScalePolicy::Type arg2 ;
31692
31693   arg1 = (Dali::Actor *)jarg1;
31694   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31695   {
31696     try {
31697       (arg1)->SetSizeScalePolicy(arg2);
31698     } catch (std::out_of_range& e) {
31699       {
31700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31701       };
31702     } catch (std::exception& e) {
31703       {
31704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31705       };
31706     } catch (...) {
31707       {
31708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31709       };
31710     }
31711   }
31712 }
31713
31714
31715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31716   int jresult ;
31717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31718   Dali::SizeScalePolicy::Type result;
31719
31720   arg1 = (Dali::Actor *)jarg1;
31721   {
31722     try {
31723       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (...) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31735       };
31736     }
31737   }
31738   jresult = (int)result;
31739   return jresult;
31740 }
31741
31742
31743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Vector3 *arg2 = 0 ;
31746
31747   arg1 = (Dali::Actor *)jarg1;
31748   arg2 = (Dali::Vector3 *)jarg2;
31749   if (!arg2) {
31750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31751     return ;
31752   }
31753   {
31754     try {
31755       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31756     } catch (std::out_of_range& e) {
31757       {
31758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31759       };
31760     } catch (std::exception& e) {
31761       {
31762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31763       };
31764     } catch (...) {
31765       {
31766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31767       };
31768     }
31769   }
31770 }
31771
31772
31773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31774   void * jresult ;
31775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31776   Dali::Vector3 result;
31777
31778   arg1 = (Dali::Actor *)jarg1;
31779   {
31780     try {
31781       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31782     } catch (std::out_of_range& e) {
31783       {
31784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31785       };
31786     } catch (std::exception& e) {
31787       {
31788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31789       };
31790     } catch (...) {
31791       {
31792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31793       };
31794     }
31795   }
31796   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31797   return jresult;
31798 }
31799
31800
31801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31802   float jresult ;
31803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31804   float arg2 ;
31805   float result;
31806
31807   arg1 = (Dali::Actor *)jarg1;
31808   arg2 = (float)jarg2;
31809   {
31810     try {
31811       result = (float)(arg1)->GetHeightForWidth(arg2);
31812     } catch (std::out_of_range& e) {
31813       {
31814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31815       };
31816     } catch (std::exception& e) {
31817       {
31818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31819       };
31820     } catch (...) {
31821       {
31822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31823       };
31824     }
31825   }
31826   jresult = result;
31827   return jresult;
31828 }
31829
31830
31831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31832   float jresult ;
31833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31834   float arg2 ;
31835   float result;
31836
31837   arg1 = (Dali::Actor *)jarg1;
31838   arg2 = (float)jarg2;
31839   {
31840     try {
31841       result = (float)(arg1)->GetWidthForHeight(arg2);
31842     } catch (std::out_of_range& e) {
31843       {
31844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (std::exception& e) {
31847       {
31848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856   jresult = result;
31857   return jresult;
31858 }
31859
31860
31861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31862   float jresult ;
31863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31864   Dali::Dimension::Type arg2 ;
31865   float result;
31866
31867   arg1 = (Dali::Actor *)jarg1;
31868   arg2 = (Dali::Dimension::Type)jarg2;
31869   {
31870     try {
31871       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31872     } catch (std::out_of_range& e) {
31873       {
31874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (std::exception& e) {
31877       {
31878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886   jresult = result;
31887   return jresult;
31888 }
31889
31890
31891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31893   Dali::Padding *arg2 = 0 ;
31894
31895   arg1 = (Dali::Actor *)jarg1;
31896   arg2 = (Dali::Padding *)jarg2;
31897   if (!arg2) {
31898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31899     return ;
31900   }
31901   {
31902     try {
31903       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31904     } catch (std::out_of_range& e) {
31905       {
31906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31907       };
31908     } catch (std::exception& e) {
31909       {
31910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31915       };
31916     }
31917   }
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31923   Dali::Padding *arg2 = 0 ;
31924
31925   arg1 = (Dali::Actor *)jarg1;
31926   arg2 = (Dali::Padding *)jarg2;
31927   if (!arg2) {
31928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31929     return ;
31930   }
31931   {
31932     try {
31933       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31934     } catch (std::out_of_range& e) {
31935       {
31936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31937       };
31938     } catch (std::exception& e) {
31939       {
31940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31941       };
31942     } catch (...) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31945       };
31946     }
31947   }
31948 }
31949
31950
31951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31952   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31953   Dali::Vector2 *arg2 = 0 ;
31954
31955   arg1 = (Dali::Actor *)jarg1;
31956   arg2 = (Dali::Vector2 *)jarg2;
31957   if (!arg2) {
31958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31959     return ;
31960   }
31961   {
31962     try {
31963       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31964     } catch (std::out_of_range& e) {
31965       {
31966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31967       };
31968     } catch (std::exception& e) {
31969       {
31970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31971       };
31972     } catch (...) {
31973       {
31974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31975       };
31976     }
31977   }
31978 }
31979
31980
31981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31982   void * jresult ;
31983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31984   Dali::Vector2 result;
31985
31986   arg1 = (Dali::Actor *)jarg1;
31987   {
31988     try {
31989       result = (arg1)->GetMinimumSize();
31990     } catch (std::out_of_range& e) {
31991       {
31992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31993       };
31994     } catch (std::exception& e) {
31995       {
31996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31997       };
31998     } catch (...) {
31999       {
32000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32001       };
32002     }
32003   }
32004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32005   return jresult;
32006 }
32007
32008
32009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
32010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32011   Dali::Vector2 *arg2 = 0 ;
32012
32013   arg1 = (Dali::Actor *)jarg1;
32014   arg2 = (Dali::Vector2 *)jarg2;
32015   if (!arg2) {
32016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
32017     return ;
32018   }
32019   {
32020     try {
32021       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
32022     } catch (std::out_of_range& e) {
32023       {
32024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32025       };
32026     } catch (std::exception& e) {
32027       {
32028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32029       };
32030     } catch (...) {
32031       {
32032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32033       };
32034     }
32035   }
32036 }
32037
32038
32039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
32040   void * jresult ;
32041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32042   Dali::Vector2 result;
32043
32044   arg1 = (Dali::Actor *)jarg1;
32045   {
32046     try {
32047       result = (arg1)->GetMaximumSize();
32048     } catch (std::out_of_range& e) {
32049       {
32050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32051       };
32052     } catch (std::exception& e) {
32053       {
32054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32055       };
32056     } catch (...) {
32057       {
32058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32059       };
32060     }
32061   }
32062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
32063   return jresult;
32064 }
32065
32066
32067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
32068   int jresult ;
32069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32070   int result;
32071
32072   arg1 = (Dali::Actor *)jarg1;
32073   {
32074     try {
32075       result = (int)(arg1)->GetHierarchyDepth();
32076     } catch (std::out_of_range& e) {
32077       {
32078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32079       };
32080     } catch (std::exception& e) {
32081       {
32082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32083       };
32084     } catch (...) {
32085       {
32086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32087       };
32088     }
32089   }
32090   jresult = result;
32091   return jresult;
32092 }
32093
32094
32095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
32096   unsigned int jresult ;
32097   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32098   Dali::Renderer *arg2 = 0 ;
32099   unsigned int result;
32100
32101   arg1 = (Dali::Actor *)jarg1;
32102   arg2 = (Dali::Renderer *)jarg2;
32103   if (!arg2) {
32104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32105     return 0;
32106   }
32107   {
32108     try {
32109       result = (unsigned int)(arg1)->AddRenderer(*arg2);
32110     } catch (std::out_of_range& e) {
32111       {
32112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32113       };
32114     } catch (std::exception& e) {
32115       {
32116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32117       };
32118     } catch (...) {
32119       {
32120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32121       };
32122     }
32123   }
32124   jresult = result;
32125   return jresult;
32126 }
32127
32128
32129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
32130   unsigned int jresult ;
32131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32132   unsigned int result;
32133
32134   arg1 = (Dali::Actor *)jarg1;
32135   {
32136     try {
32137       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
32138     } catch (std::out_of_range& e) {
32139       {
32140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32141       };
32142     } catch (std::exception& e) {
32143       {
32144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32145       };
32146     } catch (...) {
32147       {
32148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32149       };
32150     }
32151   }
32152   jresult = result;
32153   return jresult;
32154 }
32155
32156
32157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
32158   void * jresult ;
32159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32160   unsigned int arg2 ;
32161   Dali::Renderer result;
32162
32163   arg1 = (Dali::Actor *)jarg1;
32164   arg2 = (unsigned int)jarg2;
32165   {
32166     try {
32167       result = (arg1)->GetRendererAt(arg2);
32168     } catch (std::out_of_range& e) {
32169       {
32170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32171       };
32172     } catch (std::exception& e) {
32173       {
32174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32175       };
32176     } catch (...) {
32177       {
32178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32179       };
32180     }
32181   }
32182   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32189   Dali::Renderer *arg2 = 0 ;
32190
32191   arg1 = (Dali::Actor *)jarg1;
32192   arg2 = (Dali::Renderer *)jarg2;
32193   if (!arg2) {
32194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32195     return ;
32196   }
32197   {
32198     try {
32199       (arg1)->RemoveRenderer(*arg2);
32200     } catch (std::out_of_range& e) {
32201       {
32202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32203       };
32204     } catch (std::exception& e) {
32205       {
32206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32207       };
32208     } catch (...) {
32209       {
32210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32211       };
32212     }
32213   }
32214 }
32215
32216
32217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32219   unsigned int arg2 ;
32220
32221   arg1 = (Dali::Actor *)jarg1;
32222   arg2 = (unsigned int)jarg2;
32223   {
32224     try {
32225       (arg1)->RemoveRenderer(arg2);
32226     } catch (std::out_of_range& e) {
32227       {
32228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32229       };
32230     } catch (std::exception& e) {
32231       {
32232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32233       };
32234     } catch (...) {
32235       {
32236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32237       };
32238     }
32239   }
32240 }
32241
32242
32243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32244   void * jresult ;
32245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32246   Dali::Actor::TouchSignalType *result = 0 ;
32247
32248   arg1 = (Dali::Actor *)jarg1;
32249   {
32250     try {
32251       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32252     } catch (std::out_of_range& e) {
32253       {
32254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32255       };
32256     } catch (std::exception& e) {
32257       {
32258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32259       };
32260     } catch (...) {
32261       {
32262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32263       };
32264     }
32265   }
32266   jresult = (void *)result;
32267   return jresult;
32268 }
32269
32270
32271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32272   void * jresult ;
32273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32274   Dali::Actor::TouchDataSignalType *result = 0 ;
32275
32276   arg1 = (Dali::Actor *)jarg1;
32277   {
32278     try {
32279       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32287       };
32288     } catch (...) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32291       };
32292     }
32293   }
32294   jresult = (void *)result;
32295   return jresult;
32296 }
32297
32298
32299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32300   void * jresult ;
32301   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32302   Dali::Actor::HoverSignalType *result = 0 ;
32303
32304   arg1 = (Dali::Actor *)jarg1;
32305   {
32306     try {
32307       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32308     } catch (std::out_of_range& e) {
32309       {
32310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32311       };
32312     } catch (std::exception& e) {
32313       {
32314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32315       };
32316     } catch (...) {
32317       {
32318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32319       };
32320     }
32321   }
32322   jresult = (void *)result;
32323   return jresult;
32324 }
32325
32326
32327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32328   void * jresult ;
32329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32330   Dali::Actor::WheelEventSignalType *result = 0 ;
32331
32332   arg1 = (Dali::Actor *)jarg1;
32333   {
32334     try {
32335       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32336     } catch (std::out_of_range& e) {
32337       {
32338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32339       };
32340     } catch (std::exception& e) {
32341       {
32342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32343       };
32344     } catch (...) {
32345       {
32346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32347       };
32348     }
32349   }
32350   jresult = (void *)result;
32351   return jresult;
32352 }
32353
32354
32355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32356   void * jresult ;
32357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32358   Dali::Actor::OnStageSignalType *result = 0 ;
32359
32360   arg1 = (Dali::Actor *)jarg1;
32361   {
32362     try {
32363       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32364     } catch (std::out_of_range& e) {
32365       {
32366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32367       };
32368     } catch (std::exception& e) {
32369       {
32370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32371       };
32372     } catch (...) {
32373       {
32374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32375       };
32376     }
32377   }
32378   jresult = (void *)result;
32379   return jresult;
32380 }
32381
32382
32383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32384   void * jresult ;
32385   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32386   Dali::Actor::OffStageSignalType *result = 0 ;
32387
32388   arg1 = (Dali::Actor *)jarg1;
32389   {
32390     try {
32391       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32392     } catch (std::out_of_range& e) {
32393       {
32394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32395       };
32396     } catch (std::exception& e) {
32397       {
32398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32399       };
32400     } catch (...) {
32401       {
32402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32403       };
32404     }
32405   }
32406   jresult = (void *)result;
32407   return jresult;
32408 }
32409
32410
32411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32412   void * jresult ;
32413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32414   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32415
32416   arg1 = (Dali::Actor *)jarg1;
32417   {
32418     try {
32419       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32420     } catch (std::out_of_range& e) {
32421       {
32422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32423       };
32424     } catch (std::exception& e) {
32425       {
32426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32427       };
32428     } catch (...) {
32429       {
32430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32431       };
32432     }
32433   }
32434   jresult = (void *)result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32440   Dali::Actor *arg1 = 0 ;
32441
32442   arg1 = (Dali::Actor *)jarg1;
32443   if (!arg1) {
32444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32445     return ;
32446   }
32447   {
32448     try {
32449       Dali::UnparentAndReset(*arg1);
32450     } catch (std::out_of_range& e) {
32451       {
32452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32453       };
32454     } catch (std::exception& e) {
32455       {
32456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32457       };
32458     } catch (...) {
32459       {
32460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32461       };
32462     }
32463   }
32464 }
32465
32466
32467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32468   int jresult ;
32469   int result;
32470
32471   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32472   jresult = (int)result;
32473   return jresult;
32474 }
32475
32476
32477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32478   int jresult ;
32479   int result;
32480
32481   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32482   jresult = (int)result;
32483   return jresult;
32484 }
32485
32486
32487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32488   int jresult ;
32489   int result;
32490
32491   result = (int)Dali::Layer::Property::BEHAVIOR;
32492   jresult = (int)result;
32493   return jresult;
32494 }
32495
32496
32497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32498   void * jresult ;
32499   Dali::Layer::Property *result = 0 ;
32500
32501   {
32502     try {
32503       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32504     } catch (std::out_of_range& e) {
32505       {
32506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32507       };
32508     } catch (std::exception& e) {
32509       {
32510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32511       };
32512     } catch (...) {
32513       {
32514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32515       };
32516     }
32517   }
32518   jresult = (void *)result;
32519   return jresult;
32520 }
32521
32522
32523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32524   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32525
32526   arg1 = (Dali::Layer::Property *)jarg1;
32527   {
32528     try {
32529       delete arg1;
32530     } catch (std::out_of_range& e) {
32531       {
32532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32533       };
32534     } catch (std::exception& e) {
32535       {
32536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32537       };
32538     } catch (...) {
32539       {
32540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32541       };
32542     }
32543   }
32544 }
32545
32546
32547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32548   void * jresult ;
32549   Dali::Layer *result = 0 ;
32550
32551   {
32552     try {
32553       result = (Dali::Layer *)new Dali::Layer();
32554     } catch (std::out_of_range& e) {
32555       {
32556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32557       };
32558     } catch (std::exception& e) {
32559       {
32560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32561       };
32562     } catch (...) {
32563       {
32564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32565       };
32566     }
32567   }
32568   jresult = (void *)result;
32569   return jresult;
32570 }
32571
32572
32573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32574   void * jresult ;
32575   Dali::Layer result;
32576
32577   {
32578     try {
32579       result = Dali::Layer::New();
32580     } catch (std::out_of_range& e) {
32581       {
32582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32583       };
32584     } catch (std::exception& e) {
32585       {
32586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32587       };
32588     } catch (...) {
32589       {
32590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32591       };
32592     }
32593   }
32594   jresult = new Dali::Layer((const Dali::Layer &)result);
32595   return jresult;
32596 }
32597
32598
32599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32600   void * jresult ;
32601   Dali::BaseHandle arg1 ;
32602   Dali::BaseHandle *argp1 ;
32603   Dali::Layer result;
32604
32605   argp1 = (Dali::BaseHandle *)jarg1;
32606   if (!argp1) {
32607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32608     return 0;
32609   }
32610   arg1 = *argp1;
32611   {
32612     try {
32613       result = Dali::Layer::DownCast(arg1);
32614     } catch (std::out_of_range& e) {
32615       {
32616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32617       };
32618     } catch (std::exception& e) {
32619       {
32620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32621       };
32622     } catch (...) {
32623       {
32624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32625       };
32626     }
32627   }
32628   jresult = new Dali::Layer((const Dali::Layer &)result);
32629   return jresult;
32630 }
32631
32632
32633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32634   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32635
32636   arg1 = (Dali::Layer *)jarg1;
32637   {
32638     try {
32639       delete arg1;
32640     } catch (std::out_of_range& e) {
32641       {
32642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32643       };
32644     } catch (std::exception& e) {
32645       {
32646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32647       };
32648     } catch (...) {
32649       {
32650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32651       };
32652     }
32653   }
32654 }
32655
32656
32657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32658   void * jresult ;
32659   Dali::Layer *arg1 = 0 ;
32660   Dali::Layer *result = 0 ;
32661
32662   arg1 = (Dali::Layer *)jarg1;
32663   if (!arg1) {
32664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32665     return 0;
32666   }
32667   {
32668     try {
32669       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32670     } catch (std::out_of_range& e) {
32671       {
32672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32673       };
32674     } catch (std::exception& e) {
32675       {
32676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32677       };
32678     } catch (...) {
32679       {
32680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32681       };
32682     }
32683   }
32684   jresult = (void *)result;
32685   return jresult;
32686 }
32687
32688
32689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32690   void * jresult ;
32691   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32692   Dali::Layer *arg2 = 0 ;
32693   Dali::Layer *result = 0 ;
32694
32695   arg1 = (Dali::Layer *)jarg1;
32696   arg2 = (Dali::Layer *)jarg2;
32697   if (!arg2) {
32698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32699     return 0;
32700   }
32701   {
32702     try {
32703       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32704     } catch (std::out_of_range& e) {
32705       {
32706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32707       };
32708     } catch (std::exception& e) {
32709       {
32710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32711       };
32712     } catch (...) {
32713       {
32714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32715       };
32716     }
32717   }
32718   jresult = (void *)result;
32719   return jresult;
32720 }
32721
32722
32723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32724   unsigned int jresult ;
32725   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32726   unsigned int result;
32727
32728   arg1 = (Dali::Layer *)jarg1;
32729   {
32730     try {
32731       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32732     } catch (std::out_of_range& e) {
32733       {
32734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32735       };
32736     } catch (std::exception& e) {
32737       {
32738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32739       };
32740     } catch (...) {
32741       {
32742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32743       };
32744     }
32745   }
32746   jresult = result;
32747   return jresult;
32748 }
32749
32750
32751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32752   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32753
32754   arg1 = (Dali::Layer *)jarg1;
32755   {
32756     try {
32757       (arg1)->Raise();
32758     } catch (std::out_of_range& e) {
32759       {
32760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32761       };
32762     } catch (std::exception& e) {
32763       {
32764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32765       };
32766     } catch (...) {
32767       {
32768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32769       };
32770     }
32771   }
32772 }
32773
32774
32775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32776   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32777
32778   arg1 = (Dali::Layer *)jarg1;
32779   {
32780     try {
32781       (arg1)->Lower();
32782     } catch (std::out_of_range& e) {
32783       {
32784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32785       };
32786     } catch (std::exception& e) {
32787       {
32788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32789       };
32790     } catch (...) {
32791       {
32792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32793       };
32794     }
32795   }
32796 }
32797
32798
32799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32800   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32801   Dali::Layer arg2 ;
32802   Dali::Layer *argp2 ;
32803
32804   arg1 = (Dali::Layer *)jarg1;
32805   argp2 = (Dali::Layer *)jarg2;
32806   if (!argp2) {
32807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32808     return ;
32809   }
32810   arg2 = *argp2;
32811   {
32812     try {
32813       (arg1)->RaiseAbove(arg2);
32814     } catch (std::out_of_range& e) {
32815       {
32816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32817       };
32818     } catch (std::exception& e) {
32819       {
32820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32821       };
32822     } catch (...) {
32823       {
32824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32825       };
32826     }
32827   }
32828 }
32829
32830
32831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32832   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32833   Dali::Layer arg2 ;
32834   Dali::Layer *argp2 ;
32835
32836   arg1 = (Dali::Layer *)jarg1;
32837   argp2 = (Dali::Layer *)jarg2;
32838   if (!argp2) {
32839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32840     return ;
32841   }
32842   arg2 = *argp2;
32843   {
32844     try {
32845       (arg1)->LowerBelow(arg2);
32846     } catch (std::out_of_range& e) {
32847       {
32848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32849       };
32850     } catch (std::exception& e) {
32851       {
32852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32853       };
32854     } catch (...) {
32855       {
32856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32857       };
32858     }
32859   }
32860 }
32861
32862
32863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32864   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32865
32866   arg1 = (Dali::Layer *)jarg1;
32867   {
32868     try {
32869       (arg1)->RaiseToTop();
32870     } catch (std::out_of_range& e) {
32871       {
32872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32873       };
32874     } catch (std::exception& e) {
32875       {
32876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32877       };
32878     } catch (...) {
32879       {
32880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32881       };
32882     }
32883   }
32884 }
32885
32886
32887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32889
32890   arg1 = (Dali::Layer *)jarg1;
32891   {
32892     try {
32893       (arg1)->LowerToBottom();
32894     } catch (std::out_of_range& e) {
32895       {
32896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32897       };
32898     } catch (std::exception& e) {
32899       {
32900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32901       };
32902     } catch (...) {
32903       {
32904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32905       };
32906     }
32907   }
32908 }
32909
32910
32911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32912   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32913   Dali::Layer arg2 ;
32914   Dali::Layer *argp2 ;
32915
32916   arg1 = (Dali::Layer *)jarg1;
32917   argp2 = (Dali::Layer *)jarg2;
32918   if (!argp2) {
32919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32920     return ;
32921   }
32922   arg2 = *argp2;
32923   {
32924     try {
32925       (arg1)->MoveAbove(arg2);
32926     } catch (std::out_of_range& e) {
32927       {
32928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32929       };
32930     } catch (std::exception& e) {
32931       {
32932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32933       };
32934     } catch (...) {
32935       {
32936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32937       };
32938     }
32939   }
32940 }
32941
32942
32943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32944   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32945   Dali::Layer arg2 ;
32946   Dali::Layer *argp2 ;
32947
32948   arg1 = (Dali::Layer *)jarg1;
32949   argp2 = (Dali::Layer *)jarg2;
32950   if (!argp2) {
32951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32952     return ;
32953   }
32954   arg2 = *argp2;
32955   {
32956     try {
32957       (arg1)->MoveBelow(arg2);
32958     } catch (std::out_of_range& e) {
32959       {
32960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32961       };
32962     } catch (std::exception& e) {
32963       {
32964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32965       };
32966     } catch (...) {
32967       {
32968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32969       };
32970     }
32971   }
32972 }
32973
32974
32975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32976   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32977   Dali::Layer::Behavior arg2 ;
32978
32979   arg1 = (Dali::Layer *)jarg1;
32980   arg2 = (Dali::Layer::Behavior)jarg2;
32981   {
32982     try {
32983       (arg1)->SetBehavior(arg2);
32984     } catch (std::out_of_range& e) {
32985       {
32986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32987       };
32988     } catch (std::exception& e) {
32989       {
32990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32991       };
32992     } catch (...) {
32993       {
32994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32995       };
32996     }
32997   }
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33002   int jresult ;
33003   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33004   Dali::Layer::Behavior result;
33005
33006   arg1 = (Dali::Layer *)jarg1;
33007   {
33008     try {
33009       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33010     } catch (std::out_of_range& e) {
33011       {
33012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33013       };
33014     } catch (std::exception& e) {
33015       {
33016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33017       };
33018     } catch (...) {
33019       {
33020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33021       };
33022     }
33023   }
33024   jresult = (int)result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33030   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33031   bool arg2 ;
33032
33033   arg1 = (Dali::Layer *)jarg1;
33034   arg2 = jarg2 ? true : false;
33035   {
33036     try {
33037       (arg1)->SetClipping(arg2);
33038     } catch (std::out_of_range& e) {
33039       {
33040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33041       };
33042     } catch (std::exception& e) {
33043       {
33044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33045       };
33046     } catch (...) {
33047       {
33048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33049       };
33050     }
33051   }
33052 }
33053
33054
33055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33056   unsigned int jresult ;
33057   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33058   bool result;
33059
33060   arg1 = (Dali::Layer *)jarg1;
33061   {
33062     try {
33063       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33064     } catch (std::out_of_range& e) {
33065       {
33066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33067       };
33068     } catch (std::exception& e) {
33069       {
33070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33071       };
33072     } catch (...) {
33073       {
33074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33075       };
33076     }
33077   }
33078   jresult = result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33084   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33085   int arg2 ;
33086   int arg3 ;
33087   int arg4 ;
33088   int arg5 ;
33089
33090   arg1 = (Dali::Layer *)jarg1;
33091   arg2 = (int)jarg2;
33092   arg3 = (int)jarg3;
33093   arg4 = (int)jarg4;
33094   arg5 = (int)jarg5;
33095   {
33096     try {
33097       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33098     } catch (std::out_of_range& e) {
33099       {
33100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33101       };
33102     } catch (std::exception& e) {
33103       {
33104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33105       };
33106     } catch (...) {
33107       {
33108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33109       };
33110     }
33111   }
33112 }
33113
33114
33115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33116   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33117   Dali::ClippingBox arg2 ;
33118   Dali::ClippingBox *argp2 ;
33119
33120   arg1 = (Dali::Layer *)jarg1;
33121   argp2 = (Dali::ClippingBox *)jarg2;
33122   if (!argp2) {
33123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33124     return ;
33125   }
33126   arg2 = *argp2;
33127   {
33128     try {
33129       (arg1)->SetClippingBox(arg2);
33130     } catch (std::out_of_range& e) {
33131       {
33132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33133       };
33134     } catch (std::exception& e) {
33135       {
33136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33137       };
33138     } catch (...) {
33139       {
33140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33141       };
33142     }
33143   }
33144 }
33145
33146
33147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33148   void * jresult ;
33149   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33150   Dali::ClippingBox result;
33151
33152   arg1 = (Dali::Layer *)jarg1;
33153   {
33154     try {
33155       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33156     } catch (std::out_of_range& e) {
33157       {
33158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33159       };
33160     } catch (std::exception& e) {
33161       {
33162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33163       };
33164     } catch (...) {
33165       {
33166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33167       };
33168     }
33169   }
33170   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33171   return jresult;
33172 }
33173
33174
33175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33176   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33177   bool arg2 ;
33178
33179   arg1 = (Dali::Layer *)jarg1;
33180   arg2 = jarg2 ? true : false;
33181   {
33182     try {
33183       (arg1)->SetDepthTestDisabled(arg2);
33184     } catch (std::out_of_range& e) {
33185       {
33186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33187       };
33188     } catch (std::exception& e) {
33189       {
33190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33191       };
33192     } catch (...) {
33193       {
33194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33195       };
33196     }
33197   }
33198 }
33199
33200
33201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33202   unsigned int jresult ;
33203   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33204   bool result;
33205
33206   arg1 = (Dali::Layer *)jarg1;
33207   {
33208     try {
33209       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33210     } catch (std::out_of_range& e) {
33211       {
33212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33213       };
33214     } catch (std::exception& e) {
33215       {
33216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33217       };
33218     } catch (...) {
33219       {
33220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33221       };
33222     }
33223   }
33224   jresult = result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33230   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33231   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33232
33233   arg1 = (Dali::Layer *)jarg1;
33234   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33235   {
33236     try {
33237       (arg1)->SetSortFunction(arg2);
33238     } catch (std::out_of_range& e) {
33239       {
33240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33241       };
33242     } catch (std::exception& e) {
33243       {
33244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33245       };
33246     } catch (...) {
33247       {
33248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33249       };
33250     }
33251   }
33252 }
33253
33254
33255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33256   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33257   bool arg2 ;
33258
33259   arg1 = (Dali::Layer *)jarg1;
33260   arg2 = jarg2 ? true : false;
33261   {
33262     try {
33263       (arg1)->SetTouchConsumed(arg2);
33264     } catch (std::out_of_range& e) {
33265       {
33266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33267       };
33268     } catch (std::exception& e) {
33269       {
33270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33271       };
33272     } catch (...) {
33273       {
33274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33275       };
33276     }
33277   }
33278 }
33279
33280
33281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33282   unsigned int jresult ;
33283   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33284   bool result;
33285
33286   arg1 = (Dali::Layer *)jarg1;
33287   {
33288     try {
33289       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33290     } catch (std::out_of_range& e) {
33291       {
33292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33293       };
33294     } catch (std::exception& e) {
33295       {
33296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (...) {
33299       {
33300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33301       };
33302     }
33303   }
33304   jresult = result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33311   bool arg2 ;
33312
33313   arg1 = (Dali::Layer *)jarg1;
33314   arg2 = jarg2 ? true : false;
33315   {
33316     try {
33317       (arg1)->SetHoverConsumed(arg2);
33318     } catch (std::out_of_range& e) {
33319       {
33320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33321       };
33322     } catch (std::exception& e) {
33323       {
33324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33325       };
33326     } catch (...) {
33327       {
33328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33329       };
33330     }
33331   }
33332 }
33333
33334
33335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33336   unsigned int jresult ;
33337   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33338   bool result;
33339
33340   arg1 = (Dali::Layer *)jarg1;
33341   {
33342     try {
33343       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33344     } catch (std::out_of_range& e) {
33345       {
33346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33347       };
33348     } catch (std::exception& e) {
33349       {
33350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33351       };
33352     } catch (...) {
33353       {
33354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33355       };
33356     }
33357   }
33358   jresult = result;
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33364   void * jresult ;
33365   Dali::Vector4 *result = 0 ;
33366
33367   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33368   jresult = (void *)result;
33369   return jresult;
33370 }
33371
33372
33373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33374   void * jresult ;
33375   Dali::Vector4 *result = 0 ;
33376
33377   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33378   jresult = (void *)result;
33379   return jresult;
33380 }
33381
33382
33383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33384   void * jresult ;
33385   Dali::Stage *result = 0 ;
33386
33387   {
33388     try {
33389       result = (Dali::Stage *)new Dali::Stage();
33390     } catch (std::out_of_range& e) {
33391       {
33392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33393       };
33394     } catch (std::exception& e) {
33395       {
33396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33397       };
33398     } catch (...) {
33399       {
33400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33401       };
33402     }
33403   }
33404   jresult = (void *)result;
33405   return jresult;
33406 }
33407
33408
33409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33410   void * jresult ;
33411   Dali::Stage result;
33412
33413   {
33414     try {
33415       result = Dali::Stage::GetCurrent();
33416     } catch (std::out_of_range& e) {
33417       {
33418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (std::exception& e) {
33421       {
33422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33423       };
33424     } catch (...) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33427       };
33428     }
33429   }
33430   jresult = new Dali::Stage((const Dali::Stage &)result);
33431   return jresult;
33432 }
33433
33434
33435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33436   unsigned int jresult ;
33437   bool result;
33438
33439   {
33440     try {
33441       result = (bool)Dali::Stage::IsInstalled();
33442     } catch (std::out_of_range& e) {
33443       {
33444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (std::exception& e) {
33447       {
33448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456   jresult = result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33462   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33463
33464   arg1 = (Dali::Stage *)jarg1;
33465   {
33466     try {
33467       delete arg1;
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33475       };
33476     } catch (...) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33479       };
33480     }
33481   }
33482 }
33483
33484
33485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33486   void * jresult ;
33487   Dali::Stage *arg1 = 0 ;
33488   Dali::Stage *result = 0 ;
33489
33490   arg1 = (Dali::Stage *)jarg1;
33491   if (!arg1) {
33492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33493     return 0;
33494   }
33495   {
33496     try {
33497       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33498     } catch (std::out_of_range& e) {
33499       {
33500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33501       };
33502     } catch (std::exception& e) {
33503       {
33504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33505       };
33506     } catch (...) {
33507       {
33508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33509       };
33510     }
33511   }
33512   jresult = (void *)result;
33513   return jresult;
33514 }
33515
33516
33517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33518   void * jresult ;
33519   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33520   Dali::Stage *arg2 = 0 ;
33521   Dali::Stage *result = 0 ;
33522
33523   arg1 = (Dali::Stage *)jarg1;
33524   arg2 = (Dali::Stage *)jarg2;
33525   if (!arg2) {
33526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33527     return 0;
33528   }
33529   {
33530     try {
33531       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33532     } catch (std::out_of_range& e) {
33533       {
33534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (std::exception& e) {
33537       {
33538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546   jresult = (void *)result;
33547   return jresult;
33548 }
33549
33550
33551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33552   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33553   Dali::Actor *arg2 = 0 ;
33554
33555   arg1 = (Dali::Stage *)jarg1;
33556   arg2 = (Dali::Actor *)jarg2;
33557   if (!arg2) {
33558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33559     return ;
33560   }
33561   {
33562     try {
33563       (arg1)->Add(*arg2);
33564     } catch (std::out_of_range& e) {
33565       {
33566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33567       };
33568     } catch (std::exception& e) {
33569       {
33570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33571       };
33572     } catch (...) {
33573       {
33574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33575       };
33576     }
33577   }
33578 }
33579
33580
33581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33582   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33583   Dali::Actor *arg2 = 0 ;
33584
33585   arg1 = (Dali::Stage *)jarg1;
33586   arg2 = (Dali::Actor *)jarg2;
33587   if (!arg2) {
33588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33589     return ;
33590   }
33591   {
33592     try {
33593       (arg1)->Remove(*arg2);
33594     } catch (std::out_of_range& e) {
33595       {
33596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33597       };
33598     } catch (std::exception& e) {
33599       {
33600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33601       };
33602     } catch (...) {
33603       {
33604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33605       };
33606     }
33607   }
33608 }
33609
33610
33611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33612   void * jresult ;
33613   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33614   Dali::Vector2 result;
33615
33616   arg1 = (Dali::Stage *)jarg1;
33617   {
33618     try {
33619       result = ((Dali::Stage const *)arg1)->GetSize();
33620     } catch (std::out_of_range& e) {
33621       {
33622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33623       };
33624     } catch (std::exception& e) {
33625       {
33626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33627       };
33628     } catch (...) {
33629       {
33630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33631       };
33632     }
33633   }
33634   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33635   return jresult;
33636 }
33637
33638
33639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33640   void * jresult ;
33641   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33642   Dali::RenderTaskList result;
33643
33644   arg1 = (Dali::Stage *)jarg1;
33645   {
33646     try {
33647       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33648     } catch (std::out_of_range& e) {
33649       {
33650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33651       };
33652     } catch (std::exception& e) {
33653       {
33654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33655       };
33656     } catch (...) {
33657       {
33658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33659       };
33660     }
33661   }
33662   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33668   unsigned int jresult ;
33669   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33670   unsigned int result;
33671
33672   arg1 = (Dali::Stage *)jarg1;
33673   {
33674     try {
33675       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (...) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33687       };
33688     }
33689   }
33690   jresult = result;
33691   return jresult;
33692 }
33693
33694
33695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33696   void * jresult ;
33697   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33698   unsigned int arg2 ;
33699   Dali::Layer result;
33700
33701   arg1 = (Dali::Stage *)jarg1;
33702   arg2 = (unsigned int)jarg2;
33703   {
33704     try {
33705       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33706     } catch (std::out_of_range& e) {
33707       {
33708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33709       };
33710     } catch (std::exception& e) {
33711       {
33712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33713       };
33714     } catch (...) {
33715       {
33716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33717       };
33718     }
33719   }
33720   jresult = new Dali::Layer((const Dali::Layer &)result);
33721   return jresult;
33722 }
33723
33724
33725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33726   void * jresult ;
33727   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33728   Dali::Layer result;
33729
33730   arg1 = (Dali::Stage *)jarg1;
33731   {
33732     try {
33733       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33734     } catch (std::out_of_range& e) {
33735       {
33736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33737       };
33738     } catch (std::exception& e) {
33739       {
33740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33741       };
33742     } catch (...) {
33743       {
33744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33745       };
33746     }
33747   }
33748   jresult = new Dali::Layer((const Dali::Layer &)result);
33749   return jresult;
33750 }
33751
33752
33753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33754   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33755   Dali::Vector4 arg2 ;
33756   Dali::Vector4 *argp2 ;
33757
33758   arg1 = (Dali::Stage *)jarg1;
33759   argp2 = (Dali::Vector4 *)jarg2;
33760   if (!argp2) {
33761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33762     return ;
33763   }
33764   arg2 = *argp2;
33765   {
33766     try {
33767       (arg1)->SetBackgroundColor(arg2);
33768     } catch (std::out_of_range& e) {
33769       {
33770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33771       };
33772     } catch (std::exception& e) {
33773       {
33774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33775       };
33776     } catch (...) {
33777       {
33778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33779       };
33780     }
33781   }
33782 }
33783
33784
33785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33786   void * jresult ;
33787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33788   Dali::Vector4 result;
33789
33790   arg1 = (Dali::Stage *)jarg1;
33791   {
33792     try {
33793       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33794     } catch (std::out_of_range& e) {
33795       {
33796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33797       };
33798     } catch (std::exception& e) {
33799       {
33800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33801       };
33802     } catch (...) {
33803       {
33804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33805       };
33806     }
33807   }
33808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33814   void * jresult ;
33815   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33816   Dali::Vector2 result;
33817
33818   arg1 = (Dali::Stage *)jarg1;
33819   {
33820     try {
33821       result = ((Dali::Stage const *)arg1)->GetDpi();
33822     } catch (std::out_of_range& e) {
33823       {
33824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (std::exception& e) {
33827       {
33828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33833       };
33834     }
33835   }
33836   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33837   return jresult;
33838 }
33839
33840
33841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33842   void * jresult ;
33843   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33844   Dali::ObjectRegistry result;
33845
33846   arg1 = (Dali::Stage *)jarg1;
33847   {
33848     try {
33849       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33850     } catch (std::out_of_range& e) {
33851       {
33852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33853       };
33854     } catch (std::exception& e) {
33855       {
33856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (...) {
33859       {
33860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33861       };
33862     }
33863   }
33864   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33865   return jresult;
33866 }
33867
33868
33869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33871   float arg2 ;
33872
33873   arg1 = (Dali::Stage *)jarg1;
33874   arg2 = (float)jarg2;
33875   {
33876     try {
33877       (arg1)->KeepRendering(arg2);
33878     } catch (std::out_of_range& e) {
33879       {
33880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33881       };
33882     } catch (std::exception& e) {
33883       {
33884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33885       };
33886     } catch (...) {
33887       {
33888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33889       };
33890     }
33891   }
33892 }
33893
33894
33895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33896   void * jresult ;
33897   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33898   Dali::Stage::KeyEventSignalType *result = 0 ;
33899
33900   arg1 = (Dali::Stage *)jarg1;
33901   {
33902     try {
33903       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33904     } catch (std::out_of_range& e) {
33905       {
33906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33907       };
33908     } catch (std::exception& e) {
33909       {
33910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33911       };
33912     } catch (...) {
33913       {
33914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33915       };
33916     }
33917   }
33918   jresult = (void *)result;
33919   return jresult;
33920 }
33921
33922
33923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33924   void * jresult ;
33925   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33926   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33927
33928   arg1 = (Dali::Stage *)jarg1;
33929   {
33930     try {
33931       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33932     } catch (std::out_of_range& e) {
33933       {
33934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33935       };
33936     } catch (std::exception& e) {
33937       {
33938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33939       };
33940     } catch (...) {
33941       {
33942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33943       };
33944     }
33945   }
33946   jresult = (void *)result;
33947   return jresult;
33948 }
33949
33950
33951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33952   void * jresult ;
33953   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33954   Dali::Stage::TouchSignalType *result = 0 ;
33955
33956   arg1 = (Dali::Stage *)jarg1;
33957   {
33958     try {
33959       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33967       };
33968     } catch (...) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33971       };
33972     }
33973   }
33974   jresult = (void *)result;
33975   return jresult;
33976 }
33977
33978
33979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33980   void * jresult ;
33981   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33982   Dali::Stage::WheelEventSignalType *result = 0 ;
33983
33984   arg1 = (Dali::Stage *)jarg1;
33985   {
33986     try {
33987       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33988     } catch (std::out_of_range& e) {
33989       {
33990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (std::exception& e) {
33993       {
33994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002   jresult = (void *)result;
34003   return jresult;
34004 }
34005
34006
34007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34008   void * jresult ;
34009   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34010   Dali::Stage::ContextStatusSignal *result = 0 ;
34011
34012   arg1 = (Dali::Stage *)jarg1;
34013   {
34014     try {
34015       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34016     } catch (std::out_of_range& e) {
34017       {
34018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34019       };
34020     } catch (std::exception& e) {
34021       {
34022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (...) {
34025       {
34026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34027       };
34028     }
34029   }
34030   jresult = (void *)result;
34031   return jresult;
34032 }
34033
34034
34035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34036   void * jresult ;
34037   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34038   Dali::Stage::ContextStatusSignal *result = 0 ;
34039
34040   arg1 = (Dali::Stage *)jarg1;
34041   {
34042     try {
34043       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34044     } catch (std::out_of_range& e) {
34045       {
34046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34047       };
34048     } catch (std::exception& e) {
34049       {
34050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34051       };
34052     } catch (...) {
34053       {
34054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34055       };
34056     }
34057   }
34058   jresult = (void *)result;
34059   return jresult;
34060 }
34061
34062
34063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34064   void * jresult ;
34065   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34066   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34067
34068   arg1 = (Dali::Stage *)jarg1;
34069   {
34070     try {
34071       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34072     } catch (std::out_of_range& e) {
34073       {
34074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34075       };
34076     } catch (std::exception& e) {
34077       {
34078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34079       };
34080     } catch (...) {
34081       {
34082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34083       };
34084     }
34085   }
34086   jresult = (void *)result;
34087   return jresult;
34088 }
34089
34090
34091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34092   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34093
34094   arg1 = (Dali::RelayoutContainer *)jarg1;
34095   {
34096     try {
34097       delete arg1;
34098     } catch (std::out_of_range& e) {
34099       {
34100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34101       };
34102     } catch (std::exception& e) {
34103       {
34104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34109       };
34110     }
34111   }
34112 }
34113
34114
34115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34116   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34117   Dali::Actor *arg2 = 0 ;
34118   Dali::Vector2 *arg3 = 0 ;
34119
34120   arg1 = (Dali::RelayoutContainer *)jarg1;
34121   arg2 = (Dali::Actor *)jarg2;
34122   if (!arg2) {
34123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34124     return ;
34125   }
34126   arg3 = (Dali::Vector2 *)jarg3;
34127   if (!arg3) {
34128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34129     return ;
34130   }
34131   {
34132     try {
34133       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34134     } catch (std::out_of_range& e) {
34135       {
34136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34137       };
34138     } catch (std::exception& e) {
34139       {
34140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34141       };
34142     } catch (...) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34145       };
34146     }
34147   }
34148 }
34149
34150
34151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34152   void * jresult ;
34153   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34154   Dali::CustomActor result;
34155
34156   arg1 = (Dali::CustomActorImpl *)jarg1;
34157   {
34158     try {
34159       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34160     } catch (std::out_of_range& e) {
34161       {
34162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34163       };
34164     } catch (std::exception& e) {
34165       {
34166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34167       };
34168     } catch (...) {
34169       {
34170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34171       };
34172     }
34173   }
34174   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34175   return jresult;
34176 }
34177
34178
34179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34180   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34181   int arg2 ;
34182
34183   arg1 = (Dali::CustomActorImpl *)jarg1;
34184   arg2 = (int)jarg2;
34185   {
34186     try {
34187       (arg1)->OnStageConnection(arg2);
34188     } catch (std::out_of_range& e) {
34189       {
34190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34191       };
34192     } catch (std::exception& e) {
34193       {
34194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34195       };
34196     } catch (...) {
34197       {
34198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34199       };
34200     }
34201   }
34202 }
34203
34204
34205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34206   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34207
34208   arg1 = (Dali::CustomActorImpl *)jarg1;
34209   {
34210     try {
34211       (arg1)->OnStageDisconnection();
34212     } catch (std::out_of_range& e) {
34213       {
34214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34215       };
34216     } catch (std::exception& e) {
34217       {
34218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34219       };
34220     } catch (...) {
34221       {
34222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34223       };
34224     }
34225   }
34226 }
34227
34228
34229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34231   Dali::Actor *arg2 = 0 ;
34232
34233   arg1 = (Dali::CustomActorImpl *)jarg1;
34234   arg2 = (Dali::Actor *)jarg2;
34235   if (!arg2) {
34236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34237     return ;
34238   }
34239   {
34240     try {
34241       (arg1)->OnChildAdd(*arg2);
34242     } catch (std::out_of_range& e) {
34243       {
34244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34245       };
34246     } catch (std::exception& e) {
34247       {
34248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34253       };
34254     }
34255   }
34256 }
34257
34258
34259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34260   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34261   Dali::Actor *arg2 = 0 ;
34262
34263   arg1 = (Dali::CustomActorImpl *)jarg1;
34264   arg2 = (Dali::Actor *)jarg2;
34265   if (!arg2) {
34266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34267     return ;
34268   }
34269   {
34270     try {
34271       (arg1)->OnChildRemove(*arg2);
34272     } catch (std::out_of_range& e) {
34273       {
34274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (std::exception& e) {
34277       {
34278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34283       };
34284     }
34285   }
34286 }
34287
34288
34289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34290   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34291   Dali::Property::Index arg2 ;
34292   Dali::Property::Value arg3 ;
34293   Dali::Property::Value *argp3 ;
34294
34295   arg1 = (Dali::CustomActorImpl *)jarg1;
34296   arg2 = (Dali::Property::Index)jarg2;
34297   argp3 = (Dali::Property::Value *)jarg3;
34298   if (!argp3) {
34299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34300     return ;
34301   }
34302   arg3 = *argp3;
34303   {
34304     try {
34305       (arg1)->OnPropertySet(arg2,arg3);
34306     } catch (std::out_of_range& e) {
34307       {
34308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34309       };
34310     } catch (std::exception& e) {
34311       {
34312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34317       };
34318     }
34319   }
34320 }
34321
34322
34323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34324   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34325   Dali::Vector3 *arg2 = 0 ;
34326
34327   arg1 = (Dali::CustomActorImpl *)jarg1;
34328   arg2 = (Dali::Vector3 *)jarg2;
34329   if (!arg2) {
34330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34331     return ;
34332   }
34333   {
34334     try {
34335       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34336     } catch (std::out_of_range& e) {
34337       {
34338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34339       };
34340     } catch (std::exception& e) {
34341       {
34342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (...) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34347       };
34348     }
34349   }
34350 }
34351
34352
34353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34354   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34355   Dali::Animation *arg2 = 0 ;
34356   Dali::Vector3 *arg3 = 0 ;
34357
34358   arg1 = (Dali::CustomActorImpl *)jarg1;
34359   arg2 = (Dali::Animation *)jarg2;
34360   if (!arg2) {
34361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34362     return ;
34363   }
34364   arg3 = (Dali::Vector3 *)jarg3;
34365   if (!arg3) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34367     return ;
34368   }
34369   {
34370     try {
34371       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (...) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34383       };
34384     }
34385   }
34386 }
34387
34388
34389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34390   unsigned int jresult ;
34391   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34392   Dali::TouchEvent *arg2 = 0 ;
34393   bool result;
34394
34395   arg1 = (Dali::CustomActorImpl *)jarg1;
34396   arg2 = (Dali::TouchEvent *)jarg2;
34397   if (!arg2) {
34398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34399     return 0;
34400   }
34401   {
34402     try {
34403       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34404     } catch (std::out_of_range& e) {
34405       {
34406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34407       };
34408     } catch (std::exception& e) {
34409       {
34410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34411       };
34412     } catch (...) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34415       };
34416     }
34417   }
34418   jresult = result;
34419   return jresult;
34420 }
34421
34422
34423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34424   unsigned int jresult ;
34425   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34426   Dali::HoverEvent *arg2 = 0 ;
34427   bool result;
34428
34429   arg1 = (Dali::CustomActorImpl *)jarg1;
34430   arg2 = (Dali::HoverEvent *)jarg2;
34431   if (!arg2) {
34432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34433     return 0;
34434   }
34435   {
34436     try {
34437       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34438     } catch (std::out_of_range& e) {
34439       {
34440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34441       };
34442     } catch (std::exception& e) {
34443       {
34444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34449       };
34450     }
34451   }
34452   jresult = result;
34453   return jresult;
34454 }
34455
34456
34457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34458   unsigned int jresult ;
34459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34460   Dali::KeyEvent *arg2 = 0 ;
34461   bool result;
34462
34463   arg1 = (Dali::CustomActorImpl *)jarg1;
34464   arg2 = (Dali::KeyEvent *)jarg2;
34465   if (!arg2) {
34466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34467     return 0;
34468   }
34469   {
34470     try {
34471       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34479       };
34480     } catch (...) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34483       };
34484     }
34485   }
34486   jresult = result;
34487   return jresult;
34488 }
34489
34490
34491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34492   unsigned int jresult ;
34493   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34494   Dali::WheelEvent *arg2 = 0 ;
34495   bool result;
34496
34497   arg1 = (Dali::CustomActorImpl *)jarg1;
34498   arg2 = (Dali::WheelEvent *)jarg2;
34499   if (!arg2) {
34500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34501     return 0;
34502   }
34503   {
34504     try {
34505       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34506     } catch (std::out_of_range& e) {
34507       {
34508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34509       };
34510     } catch (std::exception& e) {
34511       {
34512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (...) {
34515       {
34516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34517       };
34518     }
34519   }
34520   jresult = result;
34521   return jresult;
34522 }
34523
34524
34525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34527   Dali::Vector2 *arg2 = 0 ;
34528   Dali::RelayoutContainer *arg3 = 0 ;
34529
34530   arg1 = (Dali::CustomActorImpl *)jarg1;
34531   arg2 = (Dali::Vector2 *)jarg2;
34532   if (!arg2) {
34533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34534     return ;
34535   }
34536   arg3 = (Dali::RelayoutContainer *)jarg3;
34537   if (!arg3) {
34538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34539     return ;
34540   }
34541   {
34542     try {
34543       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34544     } catch (std::out_of_range& e) {
34545       {
34546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (std::exception& e) {
34549       {
34550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558 }
34559
34560
34561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34562   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34563   Dali::ResizePolicy::Type arg2 ;
34564   Dali::Dimension::Type arg3 ;
34565
34566   arg1 = (Dali::CustomActorImpl *)jarg1;
34567   arg2 = (Dali::ResizePolicy::Type)jarg2;
34568   arg3 = (Dali::Dimension::Type)jarg3;
34569   {
34570     try {
34571       (arg1)->OnSetResizePolicy(arg2,arg3);
34572     } catch (std::out_of_range& e) {
34573       {
34574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34575       };
34576     } catch (std::exception& e) {
34577       {
34578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34579       };
34580     } catch (...) {
34581       {
34582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34583       };
34584     }
34585   }
34586 }
34587
34588
34589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34590   void * jresult ;
34591   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34592   Dali::Vector3 result;
34593
34594   arg1 = (Dali::CustomActorImpl *)jarg1;
34595   {
34596     try {
34597       result = (arg1)->GetNaturalSize();
34598     } catch (std::out_of_range& e) {
34599       {
34600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (std::exception& e) {
34603       {
34604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34605       };
34606     } catch (...) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34609       };
34610     }
34611   }
34612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34613   return jresult;
34614 }
34615
34616
34617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34618   float jresult ;
34619   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34620   Dali::Actor *arg2 = 0 ;
34621   Dali::Dimension::Type arg3 ;
34622   float result;
34623
34624   arg1 = (Dali::CustomActorImpl *)jarg1;
34625   arg2 = (Dali::Actor *)jarg2;
34626   if (!arg2) {
34627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34628     return 0;
34629   }
34630   arg3 = (Dali::Dimension::Type)jarg3;
34631   {
34632     try {
34633       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34634     } catch (std::out_of_range& e) {
34635       {
34636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34637       };
34638     } catch (std::exception& e) {
34639       {
34640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34641       };
34642     } catch (...) {
34643       {
34644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34645       };
34646     }
34647   }
34648   jresult = result;
34649   return jresult;
34650 }
34651
34652
34653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34654   float jresult ;
34655   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34656   float arg2 ;
34657   float result;
34658
34659   arg1 = (Dali::CustomActorImpl *)jarg1;
34660   arg2 = (float)jarg2;
34661   {
34662     try {
34663       result = (float)(arg1)->GetHeightForWidth(arg2);
34664     } catch (std::out_of_range& e) {
34665       {
34666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34667       };
34668     } catch (std::exception& e) {
34669       {
34670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34671       };
34672     } catch (...) {
34673       {
34674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34675       };
34676     }
34677   }
34678   jresult = result;
34679   return jresult;
34680 }
34681
34682
34683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34684   float jresult ;
34685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34686   float arg2 ;
34687   float result;
34688
34689   arg1 = (Dali::CustomActorImpl *)jarg1;
34690   arg2 = (float)jarg2;
34691   {
34692     try {
34693       result = (float)(arg1)->GetWidthForHeight(arg2);
34694     } catch (std::out_of_range& e) {
34695       {
34696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34697       };
34698     } catch (std::exception& e) {
34699       {
34700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34701       };
34702     } catch (...) {
34703       {
34704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34705       };
34706     }
34707   }
34708   jresult = result;
34709   return jresult;
34710 }
34711
34712
34713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34714   unsigned int jresult ;
34715   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34716   Dali::Dimension::Type arg2 ;
34717   bool result;
34718
34719   arg1 = (Dali::CustomActorImpl *)jarg1;
34720   arg2 = (Dali::Dimension::Type)jarg2;
34721   {
34722     try {
34723       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34724     } catch (std::out_of_range& e) {
34725       {
34726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34727       };
34728     } catch (std::exception& e) {
34729       {
34730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34731       };
34732     } catch (...) {
34733       {
34734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34735       };
34736     }
34737   }
34738   jresult = result;
34739   return jresult;
34740 }
34741
34742
34743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34744   unsigned int jresult ;
34745   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34746   bool result;
34747
34748   arg1 = (Dali::CustomActorImpl *)jarg1;
34749   {
34750     try {
34751       result = (bool)(arg1)->RelayoutDependentOnChildren();
34752     } catch (std::out_of_range& e) {
34753       {
34754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34755       };
34756     } catch (std::exception& e) {
34757       {
34758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34759       };
34760     } catch (...) {
34761       {
34762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34763       };
34764     }
34765   }
34766   jresult = result;
34767   return jresult;
34768 }
34769
34770
34771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34772   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34773   Dali::Dimension::Type arg2 ;
34774
34775   arg1 = (Dali::CustomActorImpl *)jarg1;
34776   arg2 = (Dali::Dimension::Type)jarg2;
34777   {
34778     try {
34779       (arg1)->OnCalculateRelayoutSize(arg2);
34780     } catch (std::out_of_range& e) {
34781       {
34782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34783       };
34784     } catch (std::exception& e) {
34785       {
34786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34787       };
34788     } catch (...) {
34789       {
34790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34791       };
34792     }
34793   }
34794 }
34795
34796
34797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34798   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34799   float arg2 ;
34800   Dali::Dimension::Type arg3 ;
34801
34802   arg1 = (Dali::CustomActorImpl *)jarg1;
34803   arg2 = (float)jarg2;
34804   arg3 = (Dali::Dimension::Type)jarg3;
34805   {
34806     try {
34807       (arg1)->OnLayoutNegotiated(arg2,arg3);
34808     } catch (std::out_of_range& e) {
34809       {
34810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34811       };
34812     } catch (std::exception& e) {
34813       {
34814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34815       };
34816     } catch (...) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34819       };
34820     }
34821   }
34822 }
34823
34824
34825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34826   unsigned int jresult ;
34827   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34828   bool result;
34829
34830   arg1 = (Dali::CustomActorImpl *)jarg1;
34831   {
34832     try {
34833       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34841       };
34842     } catch (...) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34845       };
34846     }
34847   }
34848   jresult = result;
34849   return jresult;
34850 }
34851
34852
34853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34854   unsigned int jresult ;
34855   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34856   bool result;
34857
34858   arg1 = (Dali::CustomActorImpl *)jarg1;
34859   {
34860     try {
34861       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34862     } catch (std::out_of_range& e) {
34863       {
34864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34865       };
34866     } catch (std::exception& e) {
34867       {
34868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34873       };
34874     }
34875   }
34876   jresult = result;
34877   return jresult;
34878 }
34879
34880
34881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34882   unsigned int jresult ;
34883   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34884   bool result;
34885
34886   arg1 = (Dali::CustomActorImpl *)jarg1;
34887   {
34888     try {
34889       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34890     } catch (std::out_of_range& e) {
34891       {
34892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34893       };
34894     } catch (std::exception& e) {
34895       {
34896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34897       };
34898     } catch (...) {
34899       {
34900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34901       };
34902     }
34903   }
34904   jresult = result;
34905   return jresult;
34906 }
34907
34908
34909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34910   unsigned int jresult ;
34911   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34912   bool result;
34913
34914   arg1 = (Dali::CustomActorImpl *)jarg1;
34915   {
34916     try {
34917       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34918     } catch (std::out_of_range& e) {
34919       {
34920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34921       };
34922     } catch (std::exception& e) {
34923       {
34924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34925       };
34926     } catch (...) {
34927       {
34928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34929       };
34930     }
34931   }
34932   jresult = result;
34933   return jresult;
34934 }
34935
34936
34937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34938   void * jresult ;
34939   Dali::CustomActor *result = 0 ;
34940
34941   {
34942     try {
34943       result = (Dali::CustomActor *)new Dali::CustomActor();
34944     } catch (std::out_of_range& e) {
34945       {
34946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34947       };
34948     } catch (std::exception& e) {
34949       {
34950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34951       };
34952     } catch (...) {
34953       {
34954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34955       };
34956     }
34957   }
34958   jresult = (void *)result;
34959   return jresult;
34960 }
34961
34962
34963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34964   void * jresult ;
34965   Dali::BaseHandle arg1 ;
34966   Dali::BaseHandle *argp1 ;
34967   Dali::CustomActor result;
34968
34969   argp1 = (Dali::BaseHandle *)jarg1;
34970   if (!argp1) {
34971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34972     return 0;
34973   }
34974   arg1 = *argp1;
34975   {
34976     try {
34977       result = Dali::CustomActor::DownCast(arg1);
34978     } catch (std::out_of_range& e) {
34979       {
34980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34981       };
34982     } catch (std::exception& e) {
34983       {
34984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34985       };
34986     } catch (...) {
34987       {
34988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34989       };
34990     }
34991   }
34992   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34993   return jresult;
34994 }
34995
34996
34997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34998   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34999
35000   arg1 = (Dali::CustomActor *)jarg1;
35001   {
35002     try {
35003       delete arg1;
35004     } catch (std::out_of_range& e) {
35005       {
35006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35007       };
35008     } catch (std::exception& e) {
35009       {
35010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35011       };
35012     } catch (...) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35015       };
35016     }
35017   }
35018 }
35019
35020
35021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35022   void * jresult ;
35023   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35024   Dali::CustomActorImpl *result = 0 ;
35025
35026   arg1 = (Dali::CustomActor *)jarg1;
35027   {
35028     try {
35029       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35030     } catch (std::out_of_range& e) {
35031       {
35032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35033       };
35034     } catch (std::exception& e) {
35035       {
35036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35037       };
35038     } catch (...) {
35039       {
35040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35041       };
35042     }
35043   }
35044   jresult = (void *)result;
35045   return jresult;
35046 }
35047
35048
35049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35050   void * jresult ;
35051   Dali::CustomActorImpl *arg1 = 0 ;
35052   Dali::CustomActor *result = 0 ;
35053
35054   arg1 = (Dali::CustomActorImpl *)jarg1;
35055   if (!arg1) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35057     return 0;
35058   }
35059   {
35060     try {
35061       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35062     } catch (std::out_of_range& e) {
35063       {
35064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35065       };
35066     } catch (std::exception& e) {
35067       {
35068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35069       };
35070     } catch (...) {
35071       {
35072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35073       };
35074     }
35075   }
35076   jresult = (void *)result;
35077   return jresult;
35078 }
35079
35080
35081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35082   void * jresult ;
35083   Dali::CustomActor *arg1 = 0 ;
35084   Dali::CustomActor *result = 0 ;
35085
35086   arg1 = (Dali::CustomActor *)jarg1;
35087   if (!arg1) {
35088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35089     return 0;
35090   }
35091   {
35092     try {
35093       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35094     } catch (std::out_of_range& e) {
35095       {
35096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35097       };
35098     } catch (std::exception& e) {
35099       {
35100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35101       };
35102     } catch (...) {
35103       {
35104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35105       };
35106     }
35107   }
35108   jresult = (void *)result;
35109   return jresult;
35110 }
35111
35112
35113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35114   void * jresult ;
35115   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35116   Dali::CustomActor *arg2 = 0 ;
35117   Dali::CustomActor *result = 0 ;
35118
35119   arg1 = (Dali::CustomActor *)jarg1;
35120   arg2 = (Dali::CustomActor *)jarg2;
35121   if (!arg2) {
35122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35123     return 0;
35124   }
35125   {
35126     try {
35127       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35128     } catch (std::out_of_range& e) {
35129       {
35130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35131       };
35132     } catch (std::exception& e) {
35133       {
35134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35135       };
35136     } catch (...) {
35137       {
35138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35139       };
35140     }
35141   }
35142   jresult = (void *)result;
35143   return jresult;
35144 }
35145
35146
35147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35148   int jresult ;
35149   int result;
35150
35151   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35152   jresult = (int)result;
35153   return jresult;
35154 }
35155
35156
35157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35158   int jresult ;
35159   int result;
35160
35161   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35162   jresult = (int)result;
35163   return jresult;
35164 }
35165
35166
35167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35168   int jresult ;
35169   int result;
35170
35171   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35172   jresult = (int)result;
35173   return jresult;
35174 }
35175
35176
35177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35178   int jresult ;
35179   int result;
35180
35181   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35182   jresult = (int)result;
35183   return jresult;
35184 }
35185
35186
35187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35188   int jresult ;
35189   int result;
35190
35191   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35192   jresult = (int)result;
35193   return jresult;
35194 }
35195
35196
35197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35198   int jresult ;
35199   int result;
35200
35201   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35202   jresult = (int)result;
35203   return jresult;
35204 }
35205
35206
35207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35208   int jresult ;
35209   int result;
35210
35211   result = (int)Dali::PanGestureDetector::Property::PANNING;
35212   jresult = (int)result;
35213   return jresult;
35214 }
35215
35216
35217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35218   void * jresult ;
35219   Dali::PanGestureDetector::Property *result = 0 ;
35220
35221   {
35222     try {
35223       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35224     } catch (std::out_of_range& e) {
35225       {
35226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35227       };
35228     } catch (std::exception& e) {
35229       {
35230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35231       };
35232     } catch (...) {
35233       {
35234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35235       };
35236     }
35237   }
35238   jresult = (void *)result;
35239   return jresult;
35240 }
35241
35242
35243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35244   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35245
35246   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35247   {
35248     try {
35249       delete arg1;
35250     } catch (std::out_of_range& e) {
35251       {
35252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35253       };
35254     } catch (std::exception& e) {
35255       {
35256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35257       };
35258     } catch (...) {
35259       {
35260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35261       };
35262     }
35263   }
35264 }
35265
35266
35267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35268   void * jresult ;
35269   Dali::Radian *result = 0 ;
35270
35271   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35272   jresult = (void *)result;
35273   return jresult;
35274 }
35275
35276
35277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35278   void * jresult ;
35279   Dali::Radian *result = 0 ;
35280
35281   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35282   jresult = (void *)result;
35283   return jresult;
35284 }
35285
35286
35287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35288   void * jresult ;
35289   Dali::Radian *result = 0 ;
35290
35291   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35292   jresult = (void *)result;
35293   return jresult;
35294 }
35295
35296
35297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35298   void * jresult ;
35299   Dali::Radian *result = 0 ;
35300
35301   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35302   jresult = (void *)result;
35303   return jresult;
35304 }
35305
35306
35307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35308   void * jresult ;
35309   Dali::Radian *result = 0 ;
35310
35311   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35312   jresult = (void *)result;
35313   return jresult;
35314 }
35315
35316
35317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35318   void * jresult ;
35319   Dali::Radian *result = 0 ;
35320
35321   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35322   jresult = (void *)result;
35323   return jresult;
35324 }
35325
35326
35327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35328   void * jresult ;
35329   Dali::Radian *result = 0 ;
35330
35331   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35332   jresult = (void *)result;
35333   return jresult;
35334 }
35335
35336
35337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35338   void * jresult ;
35339   Dali::PanGestureDetector *result = 0 ;
35340
35341   {
35342     try {
35343       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35344     } catch (std::out_of_range& e) {
35345       {
35346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35347       };
35348     } catch (std::exception& e) {
35349       {
35350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35351       };
35352     } catch (...) {
35353       {
35354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35355       };
35356     }
35357   }
35358   jresult = (void *)result;
35359   return jresult;
35360 }
35361
35362
35363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35364   void * jresult ;
35365   Dali::PanGestureDetector result;
35366
35367   {
35368     try {
35369       result = Dali::PanGestureDetector::New();
35370     } catch (std::out_of_range& e) {
35371       {
35372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35373       };
35374     } catch (std::exception& e) {
35375       {
35376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35381       };
35382     }
35383   }
35384   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35385   return jresult;
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35390   void * jresult ;
35391   Dali::BaseHandle arg1 ;
35392   Dali::BaseHandle *argp1 ;
35393   Dali::PanGestureDetector result;
35394
35395   argp1 = (Dali::BaseHandle *)jarg1;
35396   if (!argp1) {
35397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35398     return 0;
35399   }
35400   arg1 = *argp1;
35401   {
35402     try {
35403       result = Dali::PanGestureDetector::DownCast(arg1);
35404     } catch (std::out_of_range& e) {
35405       {
35406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35407       };
35408     } catch (std::exception& e) {
35409       {
35410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35411       };
35412     } catch (...) {
35413       {
35414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35415       };
35416     }
35417   }
35418   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35424   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35425
35426   arg1 = (Dali::PanGestureDetector *)jarg1;
35427   {
35428     try {
35429       delete arg1;
35430     } catch (std::out_of_range& e) {
35431       {
35432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35433       };
35434     } catch (std::exception& e) {
35435       {
35436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35437       };
35438     } catch (...) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35441       };
35442     }
35443   }
35444 }
35445
35446
35447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35448   void * jresult ;
35449   Dali::PanGestureDetector *arg1 = 0 ;
35450   Dali::PanGestureDetector *result = 0 ;
35451
35452   arg1 = (Dali::PanGestureDetector *)jarg1;
35453   if (!arg1) {
35454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35455     return 0;
35456   }
35457   {
35458     try {
35459       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35460     } catch (std::out_of_range& e) {
35461       {
35462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35463       };
35464     } catch (std::exception& e) {
35465       {
35466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35467       };
35468     } catch (...) {
35469       {
35470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35471       };
35472     }
35473   }
35474   jresult = (void *)result;
35475   return jresult;
35476 }
35477
35478
35479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35480   void * jresult ;
35481   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35482   Dali::PanGestureDetector *arg2 = 0 ;
35483   Dali::PanGestureDetector *result = 0 ;
35484
35485   arg1 = (Dali::PanGestureDetector *)jarg1;
35486   arg2 = (Dali::PanGestureDetector *)jarg2;
35487   if (!arg2) {
35488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35489     return 0;
35490   }
35491   {
35492     try {
35493       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (...) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35505       };
35506     }
35507   }
35508   jresult = (void *)result;
35509   return jresult;
35510 }
35511
35512
35513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35514   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35515   unsigned int arg2 ;
35516
35517   arg1 = (Dali::PanGestureDetector *)jarg1;
35518   arg2 = (unsigned int)jarg2;
35519   {
35520     try {
35521       (arg1)->SetMinimumTouchesRequired(arg2);
35522     } catch (std::out_of_range& e) {
35523       {
35524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35525       };
35526     } catch (std::exception& e) {
35527       {
35528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35529       };
35530     } catch (...) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35533       };
35534     }
35535   }
35536 }
35537
35538
35539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35540   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35541   unsigned int arg2 ;
35542
35543   arg1 = (Dali::PanGestureDetector *)jarg1;
35544   arg2 = (unsigned int)jarg2;
35545   {
35546     try {
35547       (arg1)->SetMaximumTouchesRequired(arg2);
35548     } catch (std::out_of_range& e) {
35549       {
35550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35551       };
35552     } catch (std::exception& e) {
35553       {
35554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35555       };
35556     } catch (...) {
35557       {
35558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35559       };
35560     }
35561   }
35562 }
35563
35564
35565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35566   unsigned int jresult ;
35567   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35568   unsigned int result;
35569
35570   arg1 = (Dali::PanGestureDetector *)jarg1;
35571   {
35572     try {
35573       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35574     } catch (std::out_of_range& e) {
35575       {
35576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35577       };
35578     } catch (std::exception& e) {
35579       {
35580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35581       };
35582     } catch (...) {
35583       {
35584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35585       };
35586     }
35587   }
35588   jresult = result;
35589   return jresult;
35590 }
35591
35592
35593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35594   unsigned int jresult ;
35595   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35596   unsigned int result;
35597
35598   arg1 = (Dali::PanGestureDetector *)jarg1;
35599   {
35600     try {
35601       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35602     } catch (std::out_of_range& e) {
35603       {
35604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35605       };
35606     } catch (std::exception& e) {
35607       {
35608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35609       };
35610     } catch (...) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35613       };
35614     }
35615   }
35616   jresult = result;
35617   return jresult;
35618 }
35619
35620
35621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35622   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35623   Dali::Radian arg2 ;
35624   Dali::Radian arg3 ;
35625   Dali::Radian *argp2 ;
35626   Dali::Radian *argp3 ;
35627
35628   arg1 = (Dali::PanGestureDetector *)jarg1;
35629   argp2 = (Dali::Radian *)jarg2;
35630   if (!argp2) {
35631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35632     return ;
35633   }
35634   arg2 = *argp2;
35635   argp3 = (Dali::Radian *)jarg3;
35636   if (!argp3) {
35637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35638     return ;
35639   }
35640   arg3 = *argp3;
35641   {
35642     try {
35643       (arg1)->AddAngle(arg2,arg3);
35644     } catch (std::out_of_range& e) {
35645       {
35646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35647       };
35648     } catch (std::exception& e) {
35649       {
35650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35651       };
35652     } catch (...) {
35653       {
35654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35655       };
35656     }
35657   }
35658 }
35659
35660
35661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35662   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35663   Dali::Radian arg2 ;
35664   Dali::Radian *argp2 ;
35665
35666   arg1 = (Dali::PanGestureDetector *)jarg1;
35667   argp2 = (Dali::Radian *)jarg2;
35668   if (!argp2) {
35669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35670     return ;
35671   }
35672   arg2 = *argp2;
35673   {
35674     try {
35675       (arg1)->AddAngle(arg2);
35676     } catch (std::out_of_range& e) {
35677       {
35678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35679       };
35680     } catch (std::exception& e) {
35681       {
35682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35683       };
35684     } catch (...) {
35685       {
35686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35687       };
35688     }
35689   }
35690 }
35691
35692
35693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35694   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35695   Dali::Radian arg2 ;
35696   Dali::Radian arg3 ;
35697   Dali::Radian *argp2 ;
35698   Dali::Radian *argp3 ;
35699
35700   arg1 = (Dali::PanGestureDetector *)jarg1;
35701   argp2 = (Dali::Radian *)jarg2;
35702   if (!argp2) {
35703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35704     return ;
35705   }
35706   arg2 = *argp2;
35707   argp3 = (Dali::Radian *)jarg3;
35708   if (!argp3) {
35709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35710     return ;
35711   }
35712   arg3 = *argp3;
35713   {
35714     try {
35715       (arg1)->AddDirection(arg2,arg3);
35716     } catch (std::out_of_range& e) {
35717       {
35718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35719       };
35720     } catch (std::exception& e) {
35721       {
35722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35723       };
35724     } catch (...) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35727       };
35728     }
35729   }
35730 }
35731
35732
35733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35734   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35735   Dali::Radian arg2 ;
35736   Dali::Radian *argp2 ;
35737
35738   arg1 = (Dali::PanGestureDetector *)jarg1;
35739   argp2 = (Dali::Radian *)jarg2;
35740   if (!argp2) {
35741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35742     return ;
35743   }
35744   arg2 = *argp2;
35745   {
35746     try {
35747       (arg1)->AddDirection(arg2);
35748     } catch (std::out_of_range& e) {
35749       {
35750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35751       };
35752     } catch (std::exception& e) {
35753       {
35754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35755       };
35756     } catch (...) {
35757       {
35758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35759       };
35760     }
35761   }
35762 }
35763
35764
35765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35766   unsigned long jresult ;
35767   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35768   size_t result;
35769
35770   arg1 = (Dali::PanGestureDetector *)jarg1;
35771   {
35772     try {
35773       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35774     } catch (std::out_of_range& e) {
35775       {
35776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35777       };
35778     } catch (std::exception& e) {
35779       {
35780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35781       };
35782     } catch (...) {
35783       {
35784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35785       };
35786     }
35787   }
35788   jresult = (unsigned long)result;
35789   return jresult;
35790 }
35791
35792
35793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35794   void * jresult ;
35795   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35796   size_t arg2 ;
35797   Dali::PanGestureDetector::AngleThresholdPair result;
35798
35799   arg1 = (Dali::PanGestureDetector *)jarg1;
35800   arg2 = (size_t)jarg2;
35801   {
35802     try {
35803       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35804     } catch (std::out_of_range& e) {
35805       {
35806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35807       };
35808     } catch (std::exception& e) {
35809       {
35810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35815       };
35816     }
35817   }
35818   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35819   return jresult;
35820 }
35821
35822
35823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35824   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35825
35826   arg1 = (Dali::PanGestureDetector *)jarg1;
35827   {
35828     try {
35829       (arg1)->ClearAngles();
35830     } catch (std::out_of_range& e) {
35831       {
35832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35833       };
35834     } catch (std::exception& e) {
35835       {
35836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35841       };
35842     }
35843   }
35844 }
35845
35846
35847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35848   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35849   Dali::Radian arg2 ;
35850   Dali::Radian *argp2 ;
35851
35852   arg1 = (Dali::PanGestureDetector *)jarg1;
35853   argp2 = (Dali::Radian *)jarg2;
35854   if (!argp2) {
35855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35856     return ;
35857   }
35858   arg2 = *argp2;
35859   {
35860     try {
35861       (arg1)->RemoveAngle(arg2);
35862     } catch (std::out_of_range& e) {
35863       {
35864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35865       };
35866     } catch (std::exception& e) {
35867       {
35868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35869       };
35870     } catch (...) {
35871       {
35872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35873       };
35874     }
35875   }
35876 }
35877
35878
35879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35880   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35881   Dali::Radian arg2 ;
35882   Dali::Radian *argp2 ;
35883
35884   arg1 = (Dali::PanGestureDetector *)jarg1;
35885   argp2 = (Dali::Radian *)jarg2;
35886   if (!argp2) {
35887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35888     return ;
35889   }
35890   arg2 = *argp2;
35891   {
35892     try {
35893       (arg1)->RemoveDirection(arg2);
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35901       };
35902     } catch (...) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35905       };
35906     }
35907   }
35908 }
35909
35910
35911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35912   void * jresult ;
35913   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35914   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35915
35916   arg1 = (Dali::PanGestureDetector *)jarg1;
35917   {
35918     try {
35919       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35920     } catch (std::out_of_range& e) {
35921       {
35922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35923       };
35924     } catch (std::exception& e) {
35925       {
35926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35927       };
35928     } catch (...) {
35929       {
35930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35931       };
35932     }
35933   }
35934   jresult = (void *)result;
35935   return jresult;
35936 }
35937
35938
35939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35940   Dali::PanGesture *arg1 = 0 ;
35941
35942   arg1 = (Dali::PanGesture *)jarg1;
35943   if (!arg1) {
35944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35945     return ;
35946   }
35947   {
35948     try {
35949       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35950     } catch (std::out_of_range& e) {
35951       {
35952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35953       };
35954     } catch (std::exception& e) {
35955       {
35956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35957       };
35958     } catch (...) {
35959       {
35960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35961       };
35962     }
35963   }
35964 }
35965
35966
35967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35968   void * jresult ;
35969   Dali::PanGesture *result = 0 ;
35970
35971   {
35972     try {
35973       result = (Dali::PanGesture *)new Dali::PanGesture();
35974     } catch (std::out_of_range& e) {
35975       {
35976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35977       };
35978     } catch (std::exception& e) {
35979       {
35980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35981       };
35982     } catch (...) {
35983       {
35984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35985       };
35986     }
35987   }
35988   jresult = (void *)result;
35989   return jresult;
35990 }
35991
35992
35993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35994   void * jresult ;
35995   Dali::Gesture::State arg1 ;
35996   Dali::PanGesture *result = 0 ;
35997
35998   arg1 = (Dali::Gesture::State)jarg1;
35999   {
36000     try {
36001       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36002     } catch (std::out_of_range& e) {
36003       {
36004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36005       };
36006     } catch (std::exception& e) {
36007       {
36008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36009       };
36010     } catch (...) {
36011       {
36012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36013       };
36014     }
36015   }
36016   jresult = (void *)result;
36017   return jresult;
36018 }
36019
36020
36021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36022   void * jresult ;
36023   Dali::PanGesture *arg1 = 0 ;
36024   Dali::PanGesture *result = 0 ;
36025
36026   arg1 = (Dali::PanGesture *)jarg1;
36027   if (!arg1) {
36028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36029     return 0;
36030   }
36031   {
36032     try {
36033       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36034     } catch (std::out_of_range& e) {
36035       {
36036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36037       };
36038     } catch (std::exception& e) {
36039       {
36040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36041       };
36042     } catch (...) {
36043       {
36044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36045       };
36046     }
36047   }
36048   jresult = (void *)result;
36049   return jresult;
36050 }
36051
36052
36053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36054   void * jresult ;
36055   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36056   Dali::PanGesture *arg2 = 0 ;
36057   Dali::PanGesture *result = 0 ;
36058
36059   arg1 = (Dali::PanGesture *)jarg1;
36060   arg2 = (Dali::PanGesture *)jarg2;
36061   if (!arg2) {
36062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36063     return 0;
36064   }
36065   {
36066     try {
36067       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36068     } catch (std::out_of_range& e) {
36069       {
36070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36071       };
36072     } catch (std::exception& e) {
36073       {
36074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36075       };
36076     } catch (...) {
36077       {
36078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36079       };
36080     }
36081   }
36082   jresult = (void *)result;
36083   return jresult;
36084 }
36085
36086
36087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36088   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36089
36090   arg1 = (Dali::PanGesture *)jarg1;
36091   {
36092     try {
36093       delete arg1;
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36101       };
36102     } catch (...) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36105       };
36106     }
36107   }
36108 }
36109
36110
36111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36112   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36113   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36114
36115   arg1 = (Dali::PanGesture *)jarg1;
36116   arg2 = (Dali::Vector2 *)jarg2;
36117   if (arg1) (arg1)->velocity = *arg2;
36118 }
36119
36120
36121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36122   void * jresult ;
36123   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36124   Dali::Vector2 *result = 0 ;
36125
36126   arg1 = (Dali::PanGesture *)jarg1;
36127   result = (Dali::Vector2 *)& ((arg1)->velocity);
36128   jresult = (void *)result;
36129   return jresult;
36130 }
36131
36132
36133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36134   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36135   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36136
36137   arg1 = (Dali::PanGesture *)jarg1;
36138   arg2 = (Dali::Vector2 *)jarg2;
36139   if (arg1) (arg1)->displacement = *arg2;
36140 }
36141
36142
36143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36144   void * jresult ;
36145   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36146   Dali::Vector2 *result = 0 ;
36147
36148   arg1 = (Dali::PanGesture *)jarg1;
36149   result = (Dali::Vector2 *)& ((arg1)->displacement);
36150   jresult = (void *)result;
36151   return jresult;
36152 }
36153
36154
36155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36156   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36157   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36158
36159   arg1 = (Dali::PanGesture *)jarg1;
36160   arg2 = (Dali::Vector2 *)jarg2;
36161   if (arg1) (arg1)->position = *arg2;
36162 }
36163
36164
36165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36166   void * jresult ;
36167   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36168   Dali::Vector2 *result = 0 ;
36169
36170   arg1 = (Dali::PanGesture *)jarg1;
36171   result = (Dali::Vector2 *)& ((arg1)->position);
36172   jresult = (void *)result;
36173   return jresult;
36174 }
36175
36176
36177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36178   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36179   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36180
36181   arg1 = (Dali::PanGesture *)jarg1;
36182   arg2 = (Dali::Vector2 *)jarg2;
36183   if (arg1) (arg1)->screenVelocity = *arg2;
36184 }
36185
36186
36187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36188   void * jresult ;
36189   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36190   Dali::Vector2 *result = 0 ;
36191
36192   arg1 = (Dali::PanGesture *)jarg1;
36193   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36194   jresult = (void *)result;
36195   return jresult;
36196 }
36197
36198
36199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36200   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36201   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36202
36203   arg1 = (Dali::PanGesture *)jarg1;
36204   arg2 = (Dali::Vector2 *)jarg2;
36205   if (arg1) (arg1)->screenDisplacement = *arg2;
36206 }
36207
36208
36209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36210   void * jresult ;
36211   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36212   Dali::Vector2 *result = 0 ;
36213
36214   arg1 = (Dali::PanGesture *)jarg1;
36215   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36216   jresult = (void *)result;
36217   return jresult;
36218 }
36219
36220
36221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36222   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36223   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36224
36225   arg1 = (Dali::PanGesture *)jarg1;
36226   arg2 = (Dali::Vector2 *)jarg2;
36227   if (arg1) (arg1)->screenPosition = *arg2;
36228 }
36229
36230
36231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36232   void * jresult ;
36233   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36234   Dali::Vector2 *result = 0 ;
36235
36236   arg1 = (Dali::PanGesture *)jarg1;
36237   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36238   jresult = (void *)result;
36239   return jresult;
36240 }
36241
36242
36243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36244   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36245   unsigned int arg2 ;
36246
36247   arg1 = (Dali::PanGesture *)jarg1;
36248   arg2 = (unsigned int)jarg2;
36249   if (arg1) (arg1)->numberOfTouches = arg2;
36250 }
36251
36252
36253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36254   unsigned int jresult ;
36255   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36256   unsigned int result;
36257
36258   arg1 = (Dali::PanGesture *)jarg1;
36259   result = (unsigned int) ((arg1)->numberOfTouches);
36260   jresult = result;
36261   return jresult;
36262 }
36263
36264
36265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36266   float jresult ;
36267   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36268   float result;
36269
36270   arg1 = (Dali::PanGesture *)jarg1;
36271   {
36272     try {
36273       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36274     } catch (std::out_of_range& e) {
36275       {
36276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36277       };
36278     } catch (std::exception& e) {
36279       {
36280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36281       };
36282     } catch (...) {
36283       {
36284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36285       };
36286     }
36287   }
36288   jresult = result;
36289   return jresult;
36290 }
36291
36292
36293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36294   float jresult ;
36295   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36296   float result;
36297
36298   arg1 = (Dali::PanGesture *)jarg1;
36299   {
36300     try {
36301       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36302     } catch (std::out_of_range& e) {
36303       {
36304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36305       };
36306     } catch (std::exception& e) {
36307       {
36308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36309       };
36310     } catch (...) {
36311       {
36312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36313       };
36314     }
36315   }
36316   jresult = result;
36317   return jresult;
36318 }
36319
36320
36321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36322   float jresult ;
36323   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36324   float result;
36325
36326   arg1 = (Dali::PanGesture *)jarg1;
36327   {
36328     try {
36329       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36330     } catch (std::out_of_range& e) {
36331       {
36332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36333       };
36334     } catch (std::exception& e) {
36335       {
36336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36337       };
36338     } catch (...) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36341       };
36342     }
36343   }
36344   jresult = result;
36345   return jresult;
36346 }
36347
36348
36349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36350   float jresult ;
36351   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36352   float result;
36353
36354   arg1 = (Dali::PanGesture *)jarg1;
36355   {
36356     try {
36357       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372   jresult = result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36378   void * jresult ;
36379   Dali::PinchGestureDetector *result = 0 ;
36380
36381   {
36382     try {
36383       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36384     } catch (std::out_of_range& e) {
36385       {
36386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36387       };
36388     } catch (std::exception& e) {
36389       {
36390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (...) {
36393       {
36394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36395       };
36396     }
36397   }
36398   jresult = (void *)result;
36399   return jresult;
36400 }
36401
36402
36403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36404   void * jresult ;
36405   Dali::PinchGestureDetector result;
36406
36407   {
36408     try {
36409       result = Dali::PinchGestureDetector::New();
36410     } catch (std::out_of_range& e) {
36411       {
36412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36413       };
36414     } catch (std::exception& e) {
36415       {
36416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36417       };
36418     } catch (...) {
36419       {
36420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36421       };
36422     }
36423   }
36424   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36425   return jresult;
36426 }
36427
36428
36429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36430   void * jresult ;
36431   Dali::BaseHandle arg1 ;
36432   Dali::BaseHandle *argp1 ;
36433   Dali::PinchGestureDetector result;
36434
36435   argp1 = (Dali::BaseHandle *)jarg1;
36436   if (!argp1) {
36437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36438     return 0;
36439   }
36440   arg1 = *argp1;
36441   {
36442     try {
36443       result = Dali::PinchGestureDetector::DownCast(arg1);
36444     } catch (std::out_of_range& e) {
36445       {
36446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (std::exception& e) {
36449       {
36450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36451       };
36452     } catch (...) {
36453       {
36454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36455       };
36456     }
36457   }
36458   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36459   return jresult;
36460 }
36461
36462
36463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36464   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36465
36466   arg1 = (Dali::PinchGestureDetector *)jarg1;
36467   {
36468     try {
36469       delete arg1;
36470     } catch (std::out_of_range& e) {
36471       {
36472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36473       };
36474     } catch (std::exception& e) {
36475       {
36476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36477       };
36478     } catch (...) {
36479       {
36480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36481       };
36482     }
36483   }
36484 }
36485
36486
36487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36488   void * jresult ;
36489   Dali::PinchGestureDetector *arg1 = 0 ;
36490   Dali::PinchGestureDetector *result = 0 ;
36491
36492   arg1 = (Dali::PinchGestureDetector *)jarg1;
36493   if (!arg1) {
36494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36495     return 0;
36496   }
36497   {
36498     try {
36499       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36500     } catch (std::out_of_range& e) {
36501       {
36502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36503       };
36504     } catch (std::exception& e) {
36505       {
36506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36511       };
36512     }
36513   }
36514   jresult = (void *)result;
36515   return jresult;
36516 }
36517
36518
36519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36520   void * jresult ;
36521   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36522   Dali::PinchGestureDetector *arg2 = 0 ;
36523   Dali::PinchGestureDetector *result = 0 ;
36524
36525   arg1 = (Dali::PinchGestureDetector *)jarg1;
36526   arg2 = (Dali::PinchGestureDetector *)jarg2;
36527   if (!arg2) {
36528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36529     return 0;
36530   }
36531   {
36532     try {
36533       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36534     } catch (std::out_of_range& e) {
36535       {
36536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36537       };
36538     } catch (std::exception& e) {
36539       {
36540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36541       };
36542     } catch (...) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36545       };
36546     }
36547   }
36548   jresult = (void *)result;
36549   return jresult;
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36554   void * jresult ;
36555   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36556   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36557
36558   arg1 = (Dali::PinchGestureDetector *)jarg1;
36559   {
36560     try {
36561       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (...) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36573       };
36574     }
36575   }
36576   jresult = (void *)result;
36577   return jresult;
36578 }
36579
36580
36581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36582   void * jresult ;
36583   Dali::Gesture::State arg1 ;
36584   Dali::PinchGesture *result = 0 ;
36585
36586   arg1 = (Dali::Gesture::State)jarg1;
36587   {
36588     try {
36589       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36590     } catch (std::out_of_range& e) {
36591       {
36592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36593       };
36594     } catch (std::exception& e) {
36595       {
36596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36597       };
36598     } catch (...) {
36599       {
36600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36601       };
36602     }
36603   }
36604   jresult = (void *)result;
36605   return jresult;
36606 }
36607
36608
36609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36610   void * jresult ;
36611   Dali::PinchGesture *arg1 = 0 ;
36612   Dali::PinchGesture *result = 0 ;
36613
36614   arg1 = (Dali::PinchGesture *)jarg1;
36615   if (!arg1) {
36616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36617     return 0;
36618   }
36619   {
36620     try {
36621       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36622     } catch (std::out_of_range& e) {
36623       {
36624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36625       };
36626     } catch (std::exception& e) {
36627       {
36628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36629       };
36630     } catch (...) {
36631       {
36632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36633       };
36634     }
36635   }
36636   jresult = (void *)result;
36637   return jresult;
36638 }
36639
36640
36641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36642   void * jresult ;
36643   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36644   Dali::PinchGesture *arg2 = 0 ;
36645   Dali::PinchGesture *result = 0 ;
36646
36647   arg1 = (Dali::PinchGesture *)jarg1;
36648   arg2 = (Dali::PinchGesture *)jarg2;
36649   if (!arg2) {
36650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36651     return 0;
36652   }
36653   {
36654     try {
36655       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36656     } catch (std::out_of_range& e) {
36657       {
36658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36659       };
36660     } catch (std::exception& e) {
36661       {
36662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36663       };
36664     } catch (...) {
36665       {
36666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36667       };
36668     }
36669   }
36670   jresult = (void *)result;
36671   return jresult;
36672 }
36673
36674
36675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36676   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36677
36678   arg1 = (Dali::PinchGesture *)jarg1;
36679   {
36680     try {
36681       delete arg1;
36682     } catch (std::out_of_range& e) {
36683       {
36684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36685       };
36686     } catch (std::exception& e) {
36687       {
36688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36689       };
36690     } catch (...) {
36691       {
36692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36693       };
36694     }
36695   }
36696 }
36697
36698
36699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36700   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36701   float arg2 ;
36702
36703   arg1 = (Dali::PinchGesture *)jarg1;
36704   arg2 = (float)jarg2;
36705   if (arg1) (arg1)->scale = arg2;
36706 }
36707
36708
36709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36710   float jresult ;
36711   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36712   float result;
36713
36714   arg1 = (Dali::PinchGesture *)jarg1;
36715   result = (float) ((arg1)->scale);
36716   jresult = result;
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36722   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36723   float arg2 ;
36724
36725   arg1 = (Dali::PinchGesture *)jarg1;
36726   arg2 = (float)jarg2;
36727   if (arg1) (arg1)->speed = arg2;
36728 }
36729
36730
36731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36732   float jresult ;
36733   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36734   float result;
36735
36736   arg1 = (Dali::PinchGesture *)jarg1;
36737   result = (float) ((arg1)->speed);
36738   jresult = result;
36739   return jresult;
36740 }
36741
36742
36743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36744   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36745   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36746
36747   arg1 = (Dali::PinchGesture *)jarg1;
36748   arg2 = (Dali::Vector2 *)jarg2;
36749   if (arg1) (arg1)->screenCenterPoint = *arg2;
36750 }
36751
36752
36753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36754   void * jresult ;
36755   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36756   Dali::Vector2 *result = 0 ;
36757
36758   arg1 = (Dali::PinchGesture *)jarg1;
36759   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36760   jresult = (void *)result;
36761   return jresult;
36762 }
36763
36764
36765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36766   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36767   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36768
36769   arg1 = (Dali::PinchGesture *)jarg1;
36770   arg2 = (Dali::Vector2 *)jarg2;
36771   if (arg1) (arg1)->localCenterPoint = *arg2;
36772 }
36773
36774
36775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36776   void * jresult ;
36777   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36778   Dali::Vector2 *result = 0 ;
36779
36780   arg1 = (Dali::PinchGesture *)jarg1;
36781   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36782   jresult = (void *)result;
36783   return jresult;
36784 }
36785
36786
36787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36788   void * jresult ;
36789   Dali::TapGestureDetector *result = 0 ;
36790
36791   {
36792     try {
36793       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36794     } catch (std::out_of_range& e) {
36795       {
36796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36797       };
36798     } catch (std::exception& e) {
36799       {
36800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36801       };
36802     } catch (...) {
36803       {
36804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36805       };
36806     }
36807   }
36808   jresult = (void *)result;
36809   return jresult;
36810 }
36811
36812
36813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36814   void * jresult ;
36815   Dali::TapGestureDetector result;
36816
36817   {
36818     try {
36819       result = Dali::TapGestureDetector::New();
36820     } catch (std::out_of_range& e) {
36821       {
36822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36823       };
36824     } catch (std::exception& e) {
36825       {
36826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36827       };
36828     } catch (...) {
36829       {
36830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36831       };
36832     }
36833   }
36834   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36835   return jresult;
36836 }
36837
36838
36839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36840   void * jresult ;
36841   unsigned int arg1 ;
36842   Dali::TapGestureDetector result;
36843
36844   arg1 = (unsigned int)jarg1;
36845   {
36846     try {
36847       result = Dali::TapGestureDetector::New(arg1);
36848     } catch (std::out_of_range& e) {
36849       {
36850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36851       };
36852     } catch (std::exception& e) {
36853       {
36854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36855       };
36856     } catch (...) {
36857       {
36858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36859       };
36860     }
36861   }
36862   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36863   return jresult;
36864 }
36865
36866
36867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36868   void * jresult ;
36869   Dali::BaseHandle arg1 ;
36870   Dali::BaseHandle *argp1 ;
36871   Dali::TapGestureDetector result;
36872
36873   argp1 = (Dali::BaseHandle *)jarg1;
36874   if (!argp1) {
36875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36876     return 0;
36877   }
36878   arg1 = *argp1;
36879   {
36880     try {
36881       result = Dali::TapGestureDetector::DownCast(arg1);
36882     } catch (std::out_of_range& e) {
36883       {
36884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36885       };
36886     } catch (std::exception& e) {
36887       {
36888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36889       };
36890     } catch (...) {
36891       {
36892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36893       };
36894     }
36895   }
36896   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36897   return jresult;
36898 }
36899
36900
36901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36902   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36903
36904   arg1 = (Dali::TapGestureDetector *)jarg1;
36905   {
36906     try {
36907       delete arg1;
36908     } catch (std::out_of_range& e) {
36909       {
36910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36911       };
36912     } catch (std::exception& e) {
36913       {
36914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36915       };
36916     } catch (...) {
36917       {
36918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36919       };
36920     }
36921   }
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36926   void * jresult ;
36927   Dali::TapGestureDetector *arg1 = 0 ;
36928   Dali::TapGestureDetector *result = 0 ;
36929
36930   arg1 = (Dali::TapGestureDetector *)jarg1;
36931   if (!arg1) {
36932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36933     return 0;
36934   }
36935   {
36936     try {
36937       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36938     } catch (std::out_of_range& e) {
36939       {
36940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (std::exception& e) {
36943       {
36944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952   jresult = (void *)result;
36953   return jresult;
36954 }
36955
36956
36957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36958   void * jresult ;
36959   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36960   Dali::TapGestureDetector *arg2 = 0 ;
36961   Dali::TapGestureDetector *result = 0 ;
36962
36963   arg1 = (Dali::TapGestureDetector *)jarg1;
36964   arg2 = (Dali::TapGestureDetector *)jarg2;
36965   if (!arg2) {
36966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36967     return 0;
36968   }
36969   {
36970     try {
36971       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36972     } catch (std::out_of_range& e) {
36973       {
36974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36975       };
36976     } catch (std::exception& e) {
36977       {
36978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36979       };
36980     } catch (...) {
36981       {
36982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36983       };
36984     }
36985   }
36986   jresult = (void *)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36992   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36993   unsigned int arg2 ;
36994
36995   arg1 = (Dali::TapGestureDetector *)jarg1;
36996   arg2 = (unsigned int)jarg2;
36997   {
36998     try {
36999       (arg1)->SetMinimumTapsRequired(arg2);
37000     } catch (std::out_of_range& e) {
37001       {
37002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37003       };
37004     } catch (std::exception& e) {
37005       {
37006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37007       };
37008     } catch (...) {
37009       {
37010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37011       };
37012     }
37013   }
37014 }
37015
37016
37017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37018   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37019   unsigned int arg2 ;
37020
37021   arg1 = (Dali::TapGestureDetector *)jarg1;
37022   arg2 = (unsigned int)jarg2;
37023   {
37024     try {
37025       (arg1)->SetMaximumTapsRequired(arg2);
37026     } catch (std::out_of_range& e) {
37027       {
37028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37029       };
37030     } catch (std::exception& e) {
37031       {
37032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37033       };
37034     } catch (...) {
37035       {
37036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37037       };
37038     }
37039   }
37040 }
37041
37042
37043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37044   unsigned int jresult ;
37045   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37046   unsigned int result;
37047
37048   arg1 = (Dali::TapGestureDetector *)jarg1;
37049   {
37050     try {
37051       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37052     } catch (std::out_of_range& e) {
37053       {
37054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37055       };
37056     } catch (std::exception& e) {
37057       {
37058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37059       };
37060     } catch (...) {
37061       {
37062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37063       };
37064     }
37065   }
37066   jresult = result;
37067   return jresult;
37068 }
37069
37070
37071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37072   unsigned int jresult ;
37073   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37074   unsigned int result;
37075
37076   arg1 = (Dali::TapGestureDetector *)jarg1;
37077   {
37078     try {
37079       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37080     } catch (std::out_of_range& e) {
37081       {
37082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37083       };
37084     } catch (std::exception& e) {
37085       {
37086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37087       };
37088     } catch (...) {
37089       {
37090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37091       };
37092     }
37093   }
37094   jresult = result;
37095   return jresult;
37096 }
37097
37098
37099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37100   void * jresult ;
37101   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37102   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37103
37104   arg1 = (Dali::TapGestureDetector *)jarg1;
37105   {
37106     try {
37107       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37108     } catch (std::out_of_range& e) {
37109       {
37110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37111       };
37112     } catch (std::exception& e) {
37113       {
37114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37115       };
37116     } catch (...) {
37117       {
37118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37119       };
37120     }
37121   }
37122   jresult = (void *)result;
37123   return jresult;
37124 }
37125
37126
37127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37128   void * jresult ;
37129   Dali::TapGesture *result = 0 ;
37130
37131   {
37132     try {
37133       result = (Dali::TapGesture *)new Dali::TapGesture();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (...) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37145       };
37146     }
37147   }
37148   jresult = (void *)result;
37149   return jresult;
37150 }
37151
37152
37153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37154   void * jresult ;
37155   Dali::TapGesture *arg1 = 0 ;
37156   Dali::TapGesture *result = 0 ;
37157
37158   arg1 = (Dali::TapGesture *)jarg1;
37159   if (!arg1) {
37160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37161     return 0;
37162   }
37163   {
37164     try {
37165       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37166     } catch (std::out_of_range& e) {
37167       {
37168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37169       };
37170     } catch (std::exception& e) {
37171       {
37172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37173       };
37174     } catch (...) {
37175       {
37176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37177       };
37178     }
37179   }
37180   jresult = (void *)result;
37181   return jresult;
37182 }
37183
37184
37185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37186   void * jresult ;
37187   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37188   Dali::TapGesture *arg2 = 0 ;
37189   Dali::TapGesture *result = 0 ;
37190
37191   arg1 = (Dali::TapGesture *)jarg1;
37192   arg2 = (Dali::TapGesture *)jarg2;
37193   if (!arg2) {
37194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37195     return 0;
37196   }
37197   {
37198     try {
37199       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (...) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37211       };
37212     }
37213   }
37214   jresult = (void *)result;
37215   return jresult;
37216 }
37217
37218
37219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37220   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37221
37222   arg1 = (Dali::TapGesture *)jarg1;
37223   {
37224     try {
37225       delete arg1;
37226     } catch (std::out_of_range& e) {
37227       {
37228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37229       };
37230     } catch (std::exception& e) {
37231       {
37232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37233       };
37234     } catch (...) {
37235       {
37236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37237       };
37238     }
37239   }
37240 }
37241
37242
37243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37244   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37245   unsigned int arg2 ;
37246
37247   arg1 = (Dali::TapGesture *)jarg1;
37248   arg2 = (unsigned int)jarg2;
37249   if (arg1) (arg1)->numberOfTaps = arg2;
37250 }
37251
37252
37253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37254   unsigned int jresult ;
37255   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37256   unsigned int result;
37257
37258   arg1 = (Dali::TapGesture *)jarg1;
37259   result = (unsigned int) ((arg1)->numberOfTaps);
37260   jresult = result;
37261   return jresult;
37262 }
37263
37264
37265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37266   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37267   unsigned int arg2 ;
37268
37269   arg1 = (Dali::TapGesture *)jarg1;
37270   arg2 = (unsigned int)jarg2;
37271   if (arg1) (arg1)->numberOfTouches = arg2;
37272 }
37273
37274
37275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37276   unsigned int jresult ;
37277   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37278   unsigned int result;
37279
37280   arg1 = (Dali::TapGesture *)jarg1;
37281   result = (unsigned int) ((arg1)->numberOfTouches);
37282   jresult = result;
37283   return jresult;
37284 }
37285
37286
37287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37288   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37289   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37290
37291   arg1 = (Dali::TapGesture *)jarg1;
37292   arg2 = (Dali::Vector2 *)jarg2;
37293   if (arg1) (arg1)->screenPoint = *arg2;
37294 }
37295
37296
37297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37298   void * jresult ;
37299   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37300   Dali::Vector2 *result = 0 ;
37301
37302   arg1 = (Dali::TapGesture *)jarg1;
37303   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37304   jresult = (void *)result;
37305   return jresult;
37306 }
37307
37308
37309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37310   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37311   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37312
37313   arg1 = (Dali::TapGesture *)jarg1;
37314   arg2 = (Dali::Vector2 *)jarg2;
37315   if (arg1) (arg1)->localPoint = *arg2;
37316 }
37317
37318
37319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37320   void * jresult ;
37321   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37322   Dali::Vector2 *result = 0 ;
37323
37324   arg1 = (Dali::TapGesture *)jarg1;
37325   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37326   jresult = (void *)result;
37327   return jresult;
37328 }
37329
37330
37331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37332   void * jresult ;
37333   Dali::AlphaFunction *result = 0 ;
37334
37335   {
37336     try {
37337       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37338     } catch (std::out_of_range& e) {
37339       {
37340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37341       };
37342     } catch (std::exception& e) {
37343       {
37344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37345       };
37346     } catch (...) {
37347       {
37348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37349       };
37350     }
37351   }
37352   jresult = (void *)result;
37353   return jresult;
37354 }
37355
37356
37357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37358   void * jresult ;
37359   Dali::AlphaFunction::BuiltinFunction arg1 ;
37360   Dali::AlphaFunction *result = 0 ;
37361
37362   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37363   {
37364     try {
37365       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37366     } catch (std::out_of_range& e) {
37367       {
37368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37369       };
37370     } catch (std::exception& e) {
37371       {
37372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37377       };
37378     }
37379   }
37380   jresult = (void *)result;
37381   return jresult;
37382 }
37383
37384
37385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37386   void * jresult ;
37387   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37388   Dali::AlphaFunction *result = 0 ;
37389
37390   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37391   {
37392     try {
37393       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37394     } catch (std::out_of_range& e) {
37395       {
37396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37397       };
37398     } catch (std::exception& e) {
37399       {
37400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37401       };
37402     } catch (...) {
37403       {
37404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37405       };
37406     }
37407   }
37408   jresult = (void *)result;
37409   return jresult;
37410 }
37411
37412
37413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37414   void * jresult ;
37415   Dali::Vector2 *arg1 = 0 ;
37416   Dali::Vector2 *arg2 = 0 ;
37417   Dali::AlphaFunction *result = 0 ;
37418
37419   arg1 = (Dali::Vector2 *)jarg1;
37420   if (!arg1) {
37421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37422     return 0;
37423   }
37424   arg2 = (Dali::Vector2 *)jarg2;
37425   if (!arg2) {
37426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37427     return 0;
37428   }
37429   {
37430     try {
37431       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37432     } catch (std::out_of_range& e) {
37433       {
37434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37435       };
37436     } catch (std::exception& e) {
37437       {
37438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37439       };
37440     } catch (...) {
37441       {
37442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37443       };
37444     }
37445   }
37446   jresult = (void *)result;
37447   return jresult;
37448 }
37449
37450
37451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37452   void * jresult ;
37453   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37454   Dali::Vector4 result;
37455
37456   arg1 = (Dali::AlphaFunction *)jarg1;
37457   {
37458     try {
37459       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37460     } catch (std::out_of_range& e) {
37461       {
37462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37463       };
37464     } catch (std::exception& e) {
37465       {
37466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37467       };
37468     } catch (...) {
37469       {
37470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37471       };
37472     }
37473   }
37474   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37475   return jresult;
37476 }
37477
37478
37479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37480   void * jresult ;
37481   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37482   Dali::AlphaFunctionPrototype result;
37483
37484   arg1 = (Dali::AlphaFunction *)jarg1;
37485   {
37486     try {
37487       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37488     } catch (std::out_of_range& e) {
37489       {
37490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37491       };
37492     } catch (std::exception& e) {
37493       {
37494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37495       };
37496     } catch (...) {
37497       {
37498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37499       };
37500     }
37501   }
37502   jresult = (void *)result;
37503   return jresult;
37504 }
37505
37506
37507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37508   int jresult ;
37509   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37510   Dali::AlphaFunction::BuiltinFunction result;
37511
37512   arg1 = (Dali::AlphaFunction *)jarg1;
37513   {
37514     try {
37515       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37516     } catch (std::out_of_range& e) {
37517       {
37518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37519       };
37520     } catch (std::exception& e) {
37521       {
37522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37523       };
37524     } catch (...) {
37525       {
37526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37527       };
37528     }
37529   }
37530   jresult = (int)result;
37531   return jresult;
37532 }
37533
37534
37535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37536   int jresult ;
37537   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37538   Dali::AlphaFunction::Mode result;
37539
37540   arg1 = (Dali::AlphaFunction *)jarg1;
37541   {
37542     try {
37543       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37544     } catch (std::out_of_range& e) {
37545       {
37546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37547       };
37548     } catch (std::exception& e) {
37549       {
37550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37551       };
37552     } catch (...) {
37553       {
37554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37555       };
37556     }
37557   }
37558   jresult = (int)result;
37559   return jresult;
37560 }
37561
37562
37563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37564   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37565
37566   arg1 = (Dali::AlphaFunction *)jarg1;
37567   {
37568     try {
37569       delete arg1;
37570     } catch (std::out_of_range& e) {
37571       {
37572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37573       };
37574     } catch (std::exception& e) {
37575       {
37576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37577       };
37578     } catch (...) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37581       };
37582     }
37583   }
37584 }
37585
37586
37587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37588   void * jresult ;
37589   Dali::KeyFrames result;
37590
37591   {
37592     try {
37593       result = Dali::KeyFrames::New();
37594     } catch (std::out_of_range& e) {
37595       {
37596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37597       };
37598     } catch (std::exception& e) {
37599       {
37600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37601       };
37602     } catch (...) {
37603       {
37604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37605       };
37606     }
37607   }
37608   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37609   return jresult;
37610 }
37611
37612
37613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37614   void * jresult ;
37615   Dali::BaseHandle arg1 ;
37616   Dali::BaseHandle *argp1 ;
37617   Dali::KeyFrames result;
37618
37619   argp1 = (Dali::BaseHandle *)jarg1;
37620   if (!argp1) {
37621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37622     return 0;
37623   }
37624   arg1 = *argp1;
37625   {
37626     try {
37627       result = Dali::KeyFrames::DownCast(arg1);
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37635       };
37636     } catch (...) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37639       };
37640     }
37641   }
37642   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37643   return jresult;
37644 }
37645
37646
37647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37648   void * jresult ;
37649   Dali::KeyFrames *result = 0 ;
37650
37651   {
37652     try {
37653       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37654     } catch (std::out_of_range& e) {
37655       {
37656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37657       };
37658     } catch (std::exception& e) {
37659       {
37660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37661       };
37662     } catch (...) {
37663       {
37664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37665       };
37666     }
37667   }
37668   jresult = (void *)result;
37669   return jresult;
37670 }
37671
37672
37673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37674   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37675
37676   arg1 = (Dali::KeyFrames *)jarg1;
37677   {
37678     try {
37679       delete arg1;
37680     } catch (std::out_of_range& e) {
37681       {
37682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37683       };
37684     } catch (std::exception& e) {
37685       {
37686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37687       };
37688     } catch (...) {
37689       {
37690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37691       };
37692     }
37693   }
37694 }
37695
37696
37697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37698   void * jresult ;
37699   Dali::KeyFrames *arg1 = 0 ;
37700   Dali::KeyFrames *result = 0 ;
37701
37702   arg1 = (Dali::KeyFrames *)jarg1;
37703   if (!arg1) {
37704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37705     return 0;
37706   }
37707   {
37708     try {
37709       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37710     } catch (std::out_of_range& e) {
37711       {
37712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37713       };
37714     } catch (std::exception& e) {
37715       {
37716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (...) {
37719       {
37720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37721       };
37722     }
37723   }
37724   jresult = (void *)result;
37725   return jresult;
37726 }
37727
37728
37729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37730   void * jresult ;
37731   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37732   Dali::KeyFrames *arg2 = 0 ;
37733   Dali::KeyFrames *result = 0 ;
37734
37735   arg1 = (Dali::KeyFrames *)jarg1;
37736   arg2 = (Dali::KeyFrames *)jarg2;
37737   if (!arg2) {
37738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37739     return 0;
37740   }
37741   {
37742     try {
37743       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37744     } catch (std::out_of_range& e) {
37745       {
37746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37747       };
37748     } catch (std::exception& e) {
37749       {
37750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37751       };
37752     } catch (...) {
37753       {
37754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37755       };
37756     }
37757   }
37758   jresult = (void *)result;
37759   return jresult;
37760 }
37761
37762
37763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37764   int jresult ;
37765   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37766   Dali::Property::Type result;
37767
37768   arg1 = (Dali::KeyFrames *)jarg1;
37769   {
37770     try {
37771       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37772     } catch (std::out_of_range& e) {
37773       {
37774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37775       };
37776     } catch (std::exception& e) {
37777       {
37778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37779       };
37780     } catch (...) {
37781       {
37782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37783       };
37784     }
37785   }
37786   jresult = (int)result;
37787   return jresult;
37788 }
37789
37790
37791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37792   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37793   float arg2 ;
37794   Dali::Property::Value arg3 ;
37795   Dali::Property::Value *argp3 ;
37796
37797   arg1 = (Dali::KeyFrames *)jarg1;
37798   arg2 = (float)jarg2;
37799   argp3 = (Dali::Property::Value *)jarg3;
37800   if (!argp3) {
37801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37802     return ;
37803   }
37804   arg3 = *argp3;
37805   {
37806     try {
37807       (arg1)->Add(arg2,arg3);
37808     } catch (std::out_of_range& e) {
37809       {
37810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37811       };
37812     } catch (std::exception& e) {
37813       {
37814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37815       };
37816     } catch (...) {
37817       {
37818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37819       };
37820     }
37821   }
37822 }
37823
37824
37825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37826   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37827   float arg2 ;
37828   Dali::Property::Value arg3 ;
37829   Dali::AlphaFunction arg4 ;
37830   Dali::Property::Value *argp3 ;
37831   Dali::AlphaFunction *argp4 ;
37832
37833   arg1 = (Dali::KeyFrames *)jarg1;
37834   arg2 = (float)jarg2;
37835   argp3 = (Dali::Property::Value *)jarg3;
37836   if (!argp3) {
37837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37838     return ;
37839   }
37840   arg3 = *argp3;
37841   argp4 = (Dali::AlphaFunction *)jarg4;
37842   if (!argp4) {
37843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37844     return ;
37845   }
37846   arg4 = *argp4;
37847   {
37848     try {
37849       (arg1)->Add(arg2,arg3,arg4);
37850     } catch (std::out_of_range& e) {
37851       {
37852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37853       };
37854     } catch (std::exception& e) {
37855       {
37856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37857       };
37858     } catch (...) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37861       };
37862     }
37863   }
37864 }
37865
37866
37867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37868   int jresult ;
37869   int result;
37870
37871   result = (int)Dali::Path::Property::POINTS;
37872   jresult = (int)result;
37873   return jresult;
37874 }
37875
37876
37877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37878   int jresult ;
37879   int result;
37880
37881   result = (int)Dali::Path::Property::CONTROL_POINTS;
37882   jresult = (int)result;
37883   return jresult;
37884 }
37885
37886
37887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37888   void * jresult ;
37889   Dali::Path::Property *result = 0 ;
37890
37891   {
37892     try {
37893       result = (Dali::Path::Property *)new Dali::Path::Property();
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37901       };
37902     } catch (...) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37905       };
37906     }
37907   }
37908   jresult = (void *)result;
37909   return jresult;
37910 }
37911
37912
37913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37914   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37915
37916   arg1 = (Dali::Path::Property *)jarg1;
37917   {
37918     try {
37919       delete arg1;
37920     } catch (std::out_of_range& e) {
37921       {
37922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37923       };
37924     } catch (std::exception& e) {
37925       {
37926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37927       };
37928     } catch (...) {
37929       {
37930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37931       };
37932     }
37933   }
37934 }
37935
37936
37937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37938   void * jresult ;
37939   Dali::Path result;
37940
37941   {
37942     try {
37943       result = Dali::Path::New();
37944     } catch (std::out_of_range& e) {
37945       {
37946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37947       };
37948     } catch (std::exception& e) {
37949       {
37950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37951       };
37952     } catch (...) {
37953       {
37954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37955       };
37956     }
37957   }
37958   jresult = new Dali::Path((const Dali::Path &)result);
37959   return jresult;
37960 }
37961
37962
37963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37964   void * jresult ;
37965   Dali::BaseHandle arg1 ;
37966   Dali::BaseHandle *argp1 ;
37967   Dali::Path result;
37968
37969   argp1 = (Dali::BaseHandle *)jarg1;
37970   if (!argp1) {
37971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37972     return 0;
37973   }
37974   arg1 = *argp1;
37975   {
37976     try {
37977       result = Dali::Path::DownCast(arg1);
37978     } catch (std::out_of_range& e) {
37979       {
37980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37981       };
37982     } catch (std::exception& e) {
37983       {
37984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37989       };
37990     }
37991   }
37992   jresult = new Dali::Path((const Dali::Path &)result);
37993   return jresult;
37994 }
37995
37996
37997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37998   void * jresult ;
37999   Dali::Path *result = 0 ;
38000
38001   {
38002     try {
38003       result = (Dali::Path *)new Dali::Path();
38004     } catch (std::out_of_range& e) {
38005       {
38006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38007       };
38008     } catch (std::exception& e) {
38009       {
38010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38011       };
38012     } catch (...) {
38013       {
38014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38015       };
38016     }
38017   }
38018   jresult = (void *)result;
38019   return jresult;
38020 }
38021
38022
38023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38024   Dali::Path *arg1 = (Dali::Path *) 0 ;
38025
38026   arg1 = (Dali::Path *)jarg1;
38027   {
38028     try {
38029       delete arg1;
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38037       };
38038     } catch (...) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38041       };
38042     }
38043   }
38044 }
38045
38046
38047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38048   void * jresult ;
38049   Dali::Path *arg1 = 0 ;
38050   Dali::Path *result = 0 ;
38051
38052   arg1 = (Dali::Path *)jarg1;
38053   if (!arg1) {
38054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38055     return 0;
38056   }
38057   {
38058     try {
38059       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38060     } catch (std::out_of_range& e) {
38061       {
38062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38063       };
38064     } catch (std::exception& e) {
38065       {
38066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38067       };
38068     } catch (...) {
38069       {
38070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38071       };
38072     }
38073   }
38074   jresult = (void *)result;
38075   return jresult;
38076 }
38077
38078
38079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38080   void * jresult ;
38081   Dali::Path *arg1 = (Dali::Path *) 0 ;
38082   Dali::Path *arg2 = 0 ;
38083   Dali::Path *result = 0 ;
38084
38085   arg1 = (Dali::Path *)jarg1;
38086   arg2 = (Dali::Path *)jarg2;
38087   if (!arg2) {
38088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38089     return 0;
38090   }
38091   {
38092     try {
38093       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38094     } catch (std::out_of_range& e) {
38095       {
38096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38097       };
38098     } catch (std::exception& e) {
38099       {
38100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (...) {
38103       {
38104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38105       };
38106     }
38107   }
38108   jresult = (void *)result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38114   Dali::Path *arg1 = (Dali::Path *) 0 ;
38115   Dali::Vector3 *arg2 = 0 ;
38116
38117   arg1 = (Dali::Path *)jarg1;
38118   arg2 = (Dali::Vector3 *)jarg2;
38119   if (!arg2) {
38120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38121     return ;
38122   }
38123   {
38124     try {
38125       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38126     } catch (std::out_of_range& e) {
38127       {
38128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (std::exception& e) {
38131       {
38132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140 }
38141
38142
38143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38144   Dali::Path *arg1 = (Dali::Path *) 0 ;
38145   Dali::Vector3 *arg2 = 0 ;
38146
38147   arg1 = (Dali::Path *)jarg1;
38148   arg2 = (Dali::Vector3 *)jarg2;
38149   if (!arg2) {
38150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38151     return ;
38152   }
38153   {
38154     try {
38155       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38156     } catch (std::out_of_range& e) {
38157       {
38158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38159       };
38160     } catch (std::exception& e) {
38161       {
38162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38163       };
38164     } catch (...) {
38165       {
38166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38167       };
38168     }
38169   }
38170 }
38171
38172
38173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38174   Dali::Path *arg1 = (Dali::Path *) 0 ;
38175   float arg2 ;
38176
38177   arg1 = (Dali::Path *)jarg1;
38178   arg2 = (float)jarg2;
38179   {
38180     try {
38181       (arg1)->GenerateControlPoints(arg2);
38182     } catch (std::out_of_range& e) {
38183       {
38184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38185       };
38186     } catch (std::exception& e) {
38187       {
38188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38193       };
38194     }
38195   }
38196 }
38197
38198
38199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38200   Dali::Path *arg1 = (Dali::Path *) 0 ;
38201   float arg2 ;
38202   Dali::Vector3 *arg3 = 0 ;
38203   Dali::Vector3 *arg4 = 0 ;
38204
38205   arg1 = (Dali::Path *)jarg1;
38206   arg2 = (float)jarg2;
38207   arg3 = (Dali::Vector3 *)jarg3;
38208   if (!arg3) {
38209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38210     return ;
38211   }
38212   arg4 = (Dali::Vector3 *)jarg4;
38213   if (!arg4) {
38214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38215     return ;
38216   }
38217   {
38218     try {
38219       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38220     } catch (std::out_of_range& e) {
38221       {
38222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38223       };
38224     } catch (std::exception& e) {
38225       {
38226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38227       };
38228     } catch (...) {
38229       {
38230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38231       };
38232     }
38233   }
38234 }
38235
38236
38237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38238   void * jresult ;
38239   Dali::Path *arg1 = (Dali::Path *) 0 ;
38240   size_t arg2 ;
38241   Dali::Vector3 *result = 0 ;
38242
38243   arg1 = (Dali::Path *)jarg1;
38244   arg2 = (size_t)jarg2;
38245   {
38246     try {
38247       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38248     } catch (std::out_of_range& e) {
38249       {
38250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38251       };
38252     } catch (std::exception& e) {
38253       {
38254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38255       };
38256     } catch (...) {
38257       {
38258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38259       };
38260     }
38261   }
38262   jresult = (void *)result;
38263   return jresult;
38264 }
38265
38266
38267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38268   void * jresult ;
38269   Dali::Path *arg1 = (Dali::Path *) 0 ;
38270   size_t arg2 ;
38271   Dali::Vector3 *result = 0 ;
38272
38273   arg1 = (Dali::Path *)jarg1;
38274   arg2 = (size_t)jarg2;
38275   {
38276     try {
38277       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38278     } catch (std::out_of_range& e) {
38279       {
38280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38281       };
38282     } catch (std::exception& e) {
38283       {
38284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38285       };
38286     } catch (...) {
38287       {
38288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38289       };
38290     }
38291   }
38292   jresult = (void *)result;
38293   return jresult;
38294 }
38295
38296
38297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38298   unsigned long jresult ;
38299   Dali::Path *arg1 = (Dali::Path *) 0 ;
38300   size_t result;
38301
38302   arg1 = (Dali::Path *)jarg1;
38303   {
38304     try {
38305       result = ((Dali::Path const *)arg1)->GetPointCount();
38306     } catch (std::out_of_range& e) {
38307       {
38308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38309       };
38310     } catch (std::exception& e) {
38311       {
38312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38313       };
38314     } catch (...) {
38315       {
38316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38317       };
38318     }
38319   }
38320   jresult = (unsigned long)result;
38321   return jresult;
38322 }
38323
38324
38325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38326   void * jresult ;
38327   float arg1 ;
38328   Dali::TimePeriod *result = 0 ;
38329
38330   arg1 = (float)jarg1;
38331   {
38332     try {
38333       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38334     } catch (std::out_of_range& e) {
38335       {
38336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (std::exception& e) {
38339       {
38340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38354   void * jresult ;
38355   float arg1 ;
38356   float arg2 ;
38357   Dali::TimePeriod *result = 0 ;
38358
38359   arg1 = (float)jarg1;
38360   arg2 = (float)jarg2;
38361   {
38362     try {
38363       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38364     } catch (std::out_of_range& e) {
38365       {
38366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38367       };
38368     } catch (std::exception& e) {
38369       {
38370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38371       };
38372     } catch (...) {
38373       {
38374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38375       };
38376     }
38377   }
38378   jresult = (void *)result;
38379   return jresult;
38380 }
38381
38382
38383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38384   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38385
38386   arg1 = (Dali::TimePeriod *)jarg1;
38387   {
38388     try {
38389       delete arg1;
38390     } catch (std::out_of_range& e) {
38391       {
38392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38393       };
38394     } catch (std::exception& e) {
38395       {
38396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38397       };
38398     } catch (...) {
38399       {
38400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38401       };
38402     }
38403   }
38404 }
38405
38406
38407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38408   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38409   float arg2 ;
38410
38411   arg1 = (Dali::TimePeriod *)jarg1;
38412   arg2 = (float)jarg2;
38413   if (arg1) (arg1)->delaySeconds = arg2;
38414 }
38415
38416
38417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38418   float jresult ;
38419   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38420   float result;
38421
38422   arg1 = (Dali::TimePeriod *)jarg1;
38423   result = (float) ((arg1)->delaySeconds);
38424   jresult = result;
38425   return jresult;
38426 }
38427
38428
38429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38430   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38431   float arg2 ;
38432
38433   arg1 = (Dali::TimePeriod *)jarg1;
38434   arg2 = (float)jarg2;
38435   if (arg1) (arg1)->durationSeconds = arg2;
38436 }
38437
38438
38439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38440   float jresult ;
38441   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38442   float result;
38443
38444   arg1 = (Dali::TimePeriod *)jarg1;
38445   result = (float) ((arg1)->durationSeconds);
38446   jresult = result;
38447   return jresult;
38448 }
38449
38450
38451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38452   void * jresult ;
38453   Dali::Animation *result = 0 ;
38454
38455   {
38456     try {
38457       result = (Dali::Animation *)new Dali::Animation();
38458     } catch (std::out_of_range& e) {
38459       {
38460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38461       };
38462     } catch (std::exception& e) {
38463       {
38464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38465       };
38466     } catch (...) {
38467       {
38468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38469       };
38470     }
38471   }
38472   jresult = (void *)result;
38473   return jresult;
38474 }
38475
38476
38477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38478   void * jresult ;
38479   float arg1 ;
38480   Dali::Animation result;
38481
38482   arg1 = (float)jarg1;
38483   {
38484     try {
38485       result = Dali::Animation::New(arg1);
38486     } catch (std::out_of_range& e) {
38487       {
38488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38489       };
38490     } catch (std::exception& e) {
38491       {
38492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38493       };
38494     } catch (...) {
38495       {
38496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38497       };
38498     }
38499   }
38500   jresult = new Dali::Animation((const Dali::Animation &)result);
38501   return jresult;
38502 }
38503
38504
38505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38506   void * jresult ;
38507   Dali::BaseHandle arg1 ;
38508   Dali::BaseHandle *argp1 ;
38509   Dali::Animation result;
38510
38511   argp1 = (Dali::BaseHandle *)jarg1;
38512   if (!argp1) {
38513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38514     return 0;
38515   }
38516   arg1 = *argp1;
38517   {
38518     try {
38519       result = Dali::Animation::DownCast(arg1);
38520     } catch (std::out_of_range& e) {
38521       {
38522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38523       };
38524     } catch (std::exception& e) {
38525       {
38526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38527       };
38528     } catch (...) {
38529       {
38530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38531       };
38532     }
38533   }
38534   jresult = new Dali::Animation((const Dali::Animation &)result);
38535   return jresult;
38536 }
38537
38538
38539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38540   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38541
38542   arg1 = (Dali::Animation *)jarg1;
38543   {
38544     try {
38545       delete arg1;
38546     } catch (std::out_of_range& e) {
38547       {
38548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38549       };
38550     } catch (std::exception& e) {
38551       {
38552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38553       };
38554     } catch (...) {
38555       {
38556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38557       };
38558     }
38559   }
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38564   void * jresult ;
38565   Dali::Animation *arg1 = 0 ;
38566   Dali::Animation *result = 0 ;
38567
38568   arg1 = (Dali::Animation *)jarg1;
38569   if (!arg1) {
38570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38571     return 0;
38572   }
38573   {
38574     try {
38575       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590   jresult = (void *)result;
38591   return jresult;
38592 }
38593
38594
38595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38596   void * jresult ;
38597   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38598   Dali::Animation *arg2 = 0 ;
38599   Dali::Animation *result = 0 ;
38600
38601   arg1 = (Dali::Animation *)jarg1;
38602   arg2 = (Dali::Animation *)jarg2;
38603   if (!arg2) {
38604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38605     return 0;
38606   }
38607   {
38608     try {
38609       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38610     } catch (std::out_of_range& e) {
38611       {
38612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38613       };
38614     } catch (std::exception& e) {
38615       {
38616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38617       };
38618     } catch (...) {
38619       {
38620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38621       };
38622     }
38623   }
38624   jresult = (void *)result;
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38630   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38631   float arg2 ;
38632
38633   arg1 = (Dali::Animation *)jarg1;
38634   arg2 = (float)jarg2;
38635   {
38636     try {
38637       (arg1)->SetDuration(arg2);
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38645       };
38646     } catch (...) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38649       };
38650     }
38651   }
38652 }
38653
38654
38655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38656   float jresult ;
38657   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38658   float result;
38659
38660   arg1 = (Dali::Animation *)jarg1;
38661   {
38662     try {
38663       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (...) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38675       };
38676     }
38677   }
38678   jresult = result;
38679   return jresult;
38680 }
38681
38682
38683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38684   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38685   bool arg2 ;
38686
38687   arg1 = (Dali::Animation *)jarg1;
38688   arg2 = jarg2 ? true : false;
38689   {
38690     try {
38691       (arg1)->SetLooping(arg2);
38692     } catch (std::out_of_range& e) {
38693       {
38694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38695       };
38696     } catch (std::exception& e) {
38697       {
38698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38699       };
38700     } catch (...) {
38701       {
38702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38703       };
38704     }
38705   }
38706 }
38707
38708
38709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38710   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38711   int arg2 ;
38712
38713   arg1 = (Dali::Animation *)jarg1;
38714   arg2 = (int)jarg2;
38715   {
38716     try {
38717       (arg1)->SetLoopCount(arg2);
38718     } catch (std::out_of_range& e) {
38719       {
38720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38721       };
38722     } catch (std::exception& e) {
38723       {
38724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38725       };
38726     } catch (...) {
38727       {
38728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38729       };
38730     }
38731   }
38732 }
38733
38734
38735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38736   int jresult ;
38737   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38738   int result;
38739
38740   arg1 = (Dali::Animation *)jarg1;
38741   {
38742     try {
38743       result = (int)(arg1)->GetLoopCount();
38744     } catch (std::out_of_range& e) {
38745       {
38746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38747       };
38748     } catch (std::exception& e) {
38749       {
38750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38751       };
38752     } catch (...) {
38753       {
38754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38755       };
38756     }
38757   }
38758   jresult = result;
38759   return jresult;
38760 }
38761
38762
38763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38764   int jresult ;
38765   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38766   int result;
38767
38768   arg1 = (Dali::Animation *)jarg1;
38769   {
38770     try {
38771       result = (int)(arg1)->GetCurrentLoop();
38772     } catch (std::out_of_range& e) {
38773       {
38774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38775       };
38776     } catch (std::exception& e) {
38777       {
38778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (...) {
38781       {
38782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38783       };
38784     }
38785   }
38786   jresult = result;
38787   return jresult;
38788 }
38789
38790
38791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38792   unsigned int jresult ;
38793   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38794   bool result;
38795
38796   arg1 = (Dali::Animation *)jarg1;
38797   {
38798     try {
38799       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38807       };
38808     } catch (...) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38811       };
38812     }
38813   }
38814   jresult = result;
38815   return jresult;
38816 }
38817
38818
38819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38820   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38821   Dali::Animation::EndAction arg2 ;
38822
38823   arg1 = (Dali::Animation *)jarg1;
38824   arg2 = (Dali::Animation::EndAction)jarg2;
38825   {
38826     try {
38827       (arg1)->SetEndAction(arg2);
38828     } catch (std::out_of_range& e) {
38829       {
38830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38831       };
38832     } catch (std::exception& e) {
38833       {
38834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38835       };
38836     } catch (...) {
38837       {
38838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38839       };
38840     }
38841   }
38842 }
38843
38844
38845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38846   int jresult ;
38847   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38848   Dali::Animation::EndAction result;
38849
38850   arg1 = (Dali::Animation *)jarg1;
38851   {
38852     try {
38853       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38854     } catch (std::out_of_range& e) {
38855       {
38856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38857       };
38858     } catch (std::exception& e) {
38859       {
38860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38861       };
38862     } catch (...) {
38863       {
38864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38865       };
38866     }
38867   }
38868   jresult = (int)result;
38869   return jresult;
38870 }
38871
38872
38873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38874   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38875   Dali::Animation::EndAction arg2 ;
38876
38877   arg1 = (Dali::Animation *)jarg1;
38878   arg2 = (Dali::Animation::EndAction)jarg2;
38879   {
38880     try {
38881       (arg1)->SetDisconnectAction(arg2);
38882     } catch (std::out_of_range& e) {
38883       {
38884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38885       };
38886     } catch (std::exception& e) {
38887       {
38888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38889       };
38890     } catch (...) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38893       };
38894     }
38895   }
38896 }
38897
38898
38899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38900   int jresult ;
38901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38902   Dali::Animation::EndAction result;
38903
38904   arg1 = (Dali::Animation *)jarg1;
38905   {
38906     try {
38907       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38908     } catch (std::out_of_range& e) {
38909       {
38910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38911       };
38912     } catch (std::exception& e) {
38913       {
38914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (...) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38919       };
38920     }
38921   }
38922   jresult = (int)result;
38923   return jresult;
38924 }
38925
38926
38927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38928   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38929   Dali::AlphaFunction arg2 ;
38930   Dali::AlphaFunction *argp2 ;
38931
38932   arg1 = (Dali::Animation *)jarg1;
38933   argp2 = (Dali::AlphaFunction *)jarg2;
38934   if (!argp2) {
38935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38936     return ;
38937   }
38938   arg2 = *argp2;
38939   {
38940     try {
38941       (arg1)->SetDefaultAlphaFunction(arg2);
38942     } catch (std::out_of_range& e) {
38943       {
38944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38945       };
38946     } catch (std::exception& e) {
38947       {
38948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38949       };
38950     } catch (...) {
38951       {
38952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38953       };
38954     }
38955   }
38956 }
38957
38958
38959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38960   void * jresult ;
38961   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38962   Dali::AlphaFunction result;
38963
38964   arg1 = (Dali::Animation *)jarg1;
38965   {
38966     try {
38967       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38968     } catch (std::out_of_range& e) {
38969       {
38970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38971       };
38972     } catch (std::exception& e) {
38973       {
38974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (...) {
38977       {
38978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38979       };
38980     }
38981   }
38982   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38983   return jresult;
38984 }
38985
38986
38987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38988   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38989   float arg2 ;
38990
38991   arg1 = (Dali::Animation *)jarg1;
38992   arg2 = (float)jarg2;
38993   {
38994     try {
38995       (arg1)->SetCurrentProgress(arg2);
38996     } catch (std::out_of_range& e) {
38997       {
38998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38999       };
39000     } catch (std::exception& e) {
39001       {
39002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39003       };
39004     } catch (...) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39007       };
39008     }
39009   }
39010 }
39011
39012
39013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39014   float jresult ;
39015   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39016   float result;
39017
39018   arg1 = (Dali::Animation *)jarg1;
39019   {
39020     try {
39021       result = (float)(arg1)->GetCurrentProgress();
39022     } catch (std::out_of_range& e) {
39023       {
39024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39025       };
39026     } catch (std::exception& e) {
39027       {
39028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39029       };
39030     } catch (...) {
39031       {
39032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39033       };
39034     }
39035   }
39036   jresult = result;
39037   return jresult;
39038 }
39039
39040
39041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39042   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39043   float arg2 ;
39044
39045   arg1 = (Dali::Animation *)jarg1;
39046   arg2 = (float)jarg2;
39047   {
39048     try {
39049       (arg1)->SetSpeedFactor(arg2);
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39057       };
39058     } catch (...) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39061       };
39062     }
39063   }
39064 }
39065
39066
39067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39068   float jresult ;
39069   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39070   float result;
39071
39072   arg1 = (Dali::Animation *)jarg1;
39073   {
39074     try {
39075       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39076     } catch (std::out_of_range& e) {
39077       {
39078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39079       };
39080     } catch (std::exception& e) {
39081       {
39082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39083       };
39084     } catch (...) {
39085       {
39086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39087       };
39088     }
39089   }
39090   jresult = result;
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39096   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39097   Dali::Vector2 *arg2 = 0 ;
39098
39099   arg1 = (Dali::Animation *)jarg1;
39100   arg2 = (Dali::Vector2 *)jarg2;
39101   if (!arg2) {
39102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39103     return ;
39104   }
39105   {
39106     try {
39107       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39115       };
39116     } catch (...) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39119       };
39120     }
39121   }
39122 }
39123
39124
39125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39126   void * jresult ;
39127   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39128   Dali::Vector2 result;
39129
39130   arg1 = (Dali::Animation *)jarg1;
39131   {
39132     try {
39133       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39134     } catch (std::out_of_range& e) {
39135       {
39136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39137       };
39138     } catch (std::exception& e) {
39139       {
39140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39141       };
39142     } catch (...) {
39143       {
39144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39145       };
39146     }
39147   }
39148   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39149   return jresult;
39150 }
39151
39152
39153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39154   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39155
39156   arg1 = (Dali::Animation *)jarg1;
39157   {
39158     try {
39159       (arg1)->Play();
39160     } catch (std::out_of_range& e) {
39161       {
39162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39163       };
39164     } catch (std::exception& e) {
39165       {
39166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39167       };
39168     } catch (...) {
39169       {
39170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39171       };
39172     }
39173   }
39174 }
39175
39176
39177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39178   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39179   float arg2 ;
39180
39181   arg1 = (Dali::Animation *)jarg1;
39182   arg2 = (float)jarg2;
39183   {
39184     try {
39185       (arg1)->PlayFrom(arg2);
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39197       };
39198     }
39199   }
39200 }
39201
39202
39203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39204   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39205
39206   arg1 = (Dali::Animation *)jarg1;
39207   {
39208     try {
39209       (arg1)->Pause();
39210     } catch (std::out_of_range& e) {
39211       {
39212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (std::exception& e) {
39215       {
39216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39217       };
39218     } catch (...) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39221       };
39222     }
39223   }
39224 }
39225
39226
39227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39228   int jresult ;
39229   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39230   Dali::Animation::State result;
39231
39232   arg1 = (Dali::Animation *)jarg1;
39233   {
39234     try {
39235       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39243       };
39244     } catch (...) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39247       };
39248     }
39249   }
39250   jresult = (int)result;
39251   return jresult;
39252 }
39253
39254
39255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39256   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39257
39258   arg1 = (Dali::Animation *)jarg1;
39259   {
39260     try {
39261       (arg1)->Stop();
39262     } catch (std::out_of_range& e) {
39263       {
39264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39265       };
39266     } catch (std::exception& e) {
39267       {
39268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39269       };
39270     } catch (...) {
39271       {
39272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39273       };
39274     }
39275   }
39276 }
39277
39278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetProgressNotification(void* jarg1, float jarg2) {
39279   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39280
39281   Dali::Animation arg1 = *argp1;
39282   float arg2 = (float)jarg2;
39283
39284   {
39285     try {
39286       Dali::DevelAnimation::SetProgressNotification(arg1, arg2);
39287     } catch (std::out_of_range& e) {
39288       {
39289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39290       };
39291     } catch (std::exception& e) {
39292       {
39293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39298       };
39299     }
39300   }
39301 }
39302
39303
39304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetProgressNotification(void * jarg1) {
39305   float jresult ;
39306   Dali::Animation* argp1 = (Dali::Animation *) jarg1 ;
39307   float result;
39308
39309   Dali::Animation arg1 = *argp1;
39310   {
39311     try {
39312       result = (float)Dali::DevelAnimation::GetProgressNotification(arg1);
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 = result;
39328   return jresult;
39329 }
39330
39331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39332   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39333
39334   arg1 = (Dali::Animation *)jarg1;
39335   {
39336     try {
39337       (arg1)->Clear();
39338     } catch (std::out_of_range& e) {
39339       {
39340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39341       };
39342     } catch (std::exception& e) {
39343       {
39344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39345       };
39346     } catch (...) {
39347       {
39348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39349       };
39350     }
39351   }
39352 }
39353
39354
39355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39356   void * jresult ;
39357   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39358   Dali::Animation::AnimationSignalType *result = 0 ;
39359
39360   arg1 = (Dali::Animation *)jarg1;
39361   {
39362     try {
39363       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39364     } catch (std::out_of_range& e) {
39365       {
39366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39367       };
39368     } catch (std::exception& e) {
39369       {
39370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39371       };
39372     } catch (...) {
39373       {
39374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39375       };
39376     }
39377   }
39378   jresult = (void *)result;
39379   return jresult;
39380 }
39381
39382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_ProgressReachedSignal(void * jarg1) {
39383   void * jresult ;
39384   Dali::Animation* argp1 = (Dali::Animation*) jarg1 ;
39385   Dali::Animation::AnimationSignalType *result = 0 ;
39386
39387   Dali::Animation arg1 = *argp1;
39388   {
39389     try {
39390       result = (Dali::Animation::AnimationSignalType* ) &Dali::DevelAnimation::ProgressReachedSignal(arg1);
39391     } catch (std::out_of_range& e) {
39392       {
39393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39394       };
39395     } catch (std::exception& e) {
39396       {
39397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39398       };
39399     } catch (...) {
39400       {
39401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39402       };
39403     }
39404   }
39405   jresult = (void *)result;
39406   return jresult;
39407 }
39408
39409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39410   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39411   SwigValueWrapper< Dali::Property > arg2 ;
39412   Dali::Property::Value arg3 ;
39413   Dali::Property *argp2 ;
39414   Dali::Property::Value *argp3 ;
39415
39416   arg1 = (Dali::Animation *)jarg1;
39417   argp2 = (Dali::Property *)jarg2;
39418   if (!argp2) {
39419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39420     return ;
39421   }
39422   arg2 = *argp2;
39423   argp3 = (Dali::Property::Value *)jarg3;
39424   if (!argp3) {
39425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39426     return ;
39427   }
39428   arg3 = *argp3;
39429   {
39430     try {
39431       (arg1)->AnimateBy(arg2,arg3);
39432     } catch (std::out_of_range& e) {
39433       {
39434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39435       };
39436     } catch (std::exception& e) {
39437       {
39438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (...) {
39441       {
39442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39443       };
39444     }
39445   }
39446 }
39447
39448
39449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39450   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39451   SwigValueWrapper< Dali::Property > arg2 ;
39452   Dali::Property::Value arg3 ;
39453   Dali::AlphaFunction arg4 ;
39454   Dali::Property *argp2 ;
39455   Dali::Property::Value *argp3 ;
39456   Dali::AlphaFunction *argp4 ;
39457
39458   arg1 = (Dali::Animation *)jarg1;
39459   argp2 = (Dali::Property *)jarg2;
39460   if (!argp2) {
39461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39462     return ;
39463   }
39464   arg2 = *argp2;
39465   argp3 = (Dali::Property::Value *)jarg3;
39466   if (!argp3) {
39467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39468     return ;
39469   }
39470   arg3 = *argp3;
39471   argp4 = (Dali::AlphaFunction *)jarg4;
39472   if (!argp4) {
39473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39474     return ;
39475   }
39476   arg4 = *argp4;
39477   {
39478     try {
39479       (arg1)->AnimateBy(arg2,arg3,arg4);
39480     } catch (std::out_of_range& e) {
39481       {
39482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39483       };
39484     } catch (std::exception& e) {
39485       {
39486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39487       };
39488     } catch (...) {
39489       {
39490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39491       };
39492     }
39493   }
39494 }
39495
39496
39497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39498   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39499   SwigValueWrapper< Dali::Property > arg2 ;
39500   Dali::Property::Value arg3 ;
39501   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39502   Dali::Property *argp2 ;
39503   Dali::Property::Value *argp3 ;
39504   Dali::TimePeriod *argp4 ;
39505
39506   arg1 = (Dali::Animation *)jarg1;
39507   argp2 = (Dali::Property *)jarg2;
39508   if (!argp2) {
39509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39510     return ;
39511   }
39512   arg2 = *argp2;
39513   argp3 = (Dali::Property::Value *)jarg3;
39514   if (!argp3) {
39515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39516     return ;
39517   }
39518   arg3 = *argp3;
39519   argp4 = (Dali::TimePeriod *)jarg4;
39520   if (!argp4) {
39521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39522     return ;
39523   }
39524   arg4 = *argp4;
39525   {
39526     try {
39527       (arg1)->AnimateBy(arg2,arg3,arg4);
39528     } catch (std::out_of_range& e) {
39529       {
39530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39531       };
39532     } catch (std::exception& e) {
39533       {
39534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39535       };
39536     } catch (...) {
39537       {
39538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39539       };
39540     }
39541   }
39542 }
39543
39544
39545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39546   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39547   SwigValueWrapper< Dali::Property > arg2 ;
39548   Dali::Property::Value arg3 ;
39549   Dali::AlphaFunction arg4 ;
39550   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39551   Dali::Property *argp2 ;
39552   Dali::Property::Value *argp3 ;
39553   Dali::AlphaFunction *argp4 ;
39554   Dali::TimePeriod *argp5 ;
39555
39556   arg1 = (Dali::Animation *)jarg1;
39557   argp2 = (Dali::Property *)jarg2;
39558   if (!argp2) {
39559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39560     return ;
39561   }
39562   arg2 = *argp2;
39563   argp3 = (Dali::Property::Value *)jarg3;
39564   if (!argp3) {
39565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39566     return ;
39567   }
39568   arg3 = *argp3;
39569   argp4 = (Dali::AlphaFunction *)jarg4;
39570   if (!argp4) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39572     return ;
39573   }
39574   arg4 = *argp4;
39575   argp5 = (Dali::TimePeriod *)jarg5;
39576   if (!argp5) {
39577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39578     return ;
39579   }
39580   arg5 = *argp5;
39581   {
39582     try {
39583       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39584     } catch (std::out_of_range& e) {
39585       {
39586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39587       };
39588     } catch (std::exception& e) {
39589       {
39590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39591       };
39592     } catch (...) {
39593       {
39594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39595       };
39596     }
39597   }
39598 }
39599
39600
39601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39602   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39603   SwigValueWrapper< Dali::Property > arg2 ;
39604   Dali::Property::Value arg3 ;
39605   Dali::Property *argp2 ;
39606   Dali::Property::Value *argp3 ;
39607
39608   arg1 = (Dali::Animation *)jarg1;
39609   argp2 = (Dali::Property *)jarg2;
39610   if (!argp2) {
39611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39612     return ;
39613   }
39614   arg2 = *argp2;
39615   argp3 = (Dali::Property::Value *)jarg3;
39616   if (!argp3) {
39617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39618     return ;
39619   }
39620   arg3 = *argp3;
39621   {
39622     try {
39623       (arg1)->AnimateTo(arg2,arg3);
39624     } catch (std::out_of_range& e) {
39625       {
39626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39627       };
39628     } catch (std::exception& e) {
39629       {
39630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39635       };
39636     }
39637   }
39638 }
39639
39640
39641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39642   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39643   SwigValueWrapper< Dali::Property > arg2 ;
39644   Dali::Property::Value arg3 ;
39645   Dali::AlphaFunction arg4 ;
39646   Dali::Property *argp2 ;
39647   Dali::Property::Value *argp3 ;
39648   Dali::AlphaFunction *argp4 ;
39649
39650   arg1 = (Dali::Animation *)jarg1;
39651   argp2 = (Dali::Property *)jarg2;
39652   if (!argp2) {
39653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39654     return ;
39655   }
39656   arg2 = *argp2;
39657   argp3 = (Dali::Property::Value *)jarg3;
39658   if (!argp3) {
39659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39660     return ;
39661   }
39662   arg3 = *argp3;
39663   argp4 = (Dali::AlphaFunction *)jarg4;
39664   if (!argp4) {
39665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39666     return ;
39667   }
39668   arg4 = *argp4;
39669   {
39670     try {
39671       (arg1)->AnimateTo(arg2,arg3,arg4);
39672     } catch (std::out_of_range& e) {
39673       {
39674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39675       };
39676     } catch (std::exception& e) {
39677       {
39678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39679       };
39680     } catch (...) {
39681       {
39682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39683       };
39684     }
39685   }
39686 }
39687
39688
39689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39690   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39691   SwigValueWrapper< Dali::Property > arg2 ;
39692   Dali::Property::Value arg3 ;
39693   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39694   Dali::Property *argp2 ;
39695   Dali::Property::Value *argp3 ;
39696   Dali::TimePeriod *argp4 ;
39697
39698   arg1 = (Dali::Animation *)jarg1;
39699   argp2 = (Dali::Property *)jarg2;
39700   if (!argp2) {
39701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39702     return ;
39703   }
39704   arg2 = *argp2;
39705   argp3 = (Dali::Property::Value *)jarg3;
39706   if (!argp3) {
39707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39708     return ;
39709   }
39710   arg3 = *argp3;
39711   argp4 = (Dali::TimePeriod *)jarg4;
39712   if (!argp4) {
39713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39714     return ;
39715   }
39716   arg4 = *argp4;
39717   {
39718     try {
39719       (arg1)->AnimateTo(arg2,arg3,arg4);
39720     } catch (std::out_of_range& e) {
39721       {
39722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39723       };
39724     } catch (std::exception& e) {
39725       {
39726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39727       };
39728     } catch (...) {
39729       {
39730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39731       };
39732     }
39733   }
39734 }
39735
39736
39737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39738   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39739   SwigValueWrapper< Dali::Property > arg2 ;
39740   Dali::Property::Value arg3 ;
39741   Dali::AlphaFunction arg4 ;
39742   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39743   Dali::Property *argp2 ;
39744   Dali::Property::Value *argp3 ;
39745   Dali::AlphaFunction *argp4 ;
39746   Dali::TimePeriod *argp5 ;
39747
39748   arg1 = (Dali::Animation *)jarg1;
39749   argp2 = (Dali::Property *)jarg2;
39750   if (!argp2) {
39751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39752     return ;
39753   }
39754   arg2 = *argp2;
39755   argp3 = (Dali::Property::Value *)jarg3;
39756   if (!argp3) {
39757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39758     return ;
39759   }
39760   arg3 = *argp3;
39761   argp4 = (Dali::AlphaFunction *)jarg4;
39762   if (!argp4) {
39763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39764     return ;
39765   }
39766   arg4 = *argp4;
39767   argp5 = (Dali::TimePeriod *)jarg5;
39768   if (!argp5) {
39769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39770     return ;
39771   }
39772   arg5 = *argp5;
39773   {
39774     try {
39775       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39776     } catch (std::out_of_range& e) {
39777       {
39778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39779       };
39780     } catch (std::exception& e) {
39781       {
39782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39783       };
39784     } catch (...) {
39785       {
39786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39787       };
39788     }
39789   }
39790 }
39791
39792
39793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39794   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39795   SwigValueWrapper< Dali::Property > arg2 ;
39796   Dali::KeyFrames *arg3 = 0 ;
39797   Dali::Property *argp2 ;
39798
39799   arg1 = (Dali::Animation *)jarg1;
39800   argp2 = (Dali::Property *)jarg2;
39801   if (!argp2) {
39802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39803     return ;
39804   }
39805   arg2 = *argp2;
39806   arg3 = (Dali::KeyFrames *)jarg3;
39807   if (!arg3) {
39808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39809     return ;
39810   }
39811   {
39812     try {
39813       (arg1)->AnimateBetween(arg2,*arg3);
39814     } catch (std::out_of_range& e) {
39815       {
39816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39817       };
39818     } catch (std::exception& e) {
39819       {
39820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39821       };
39822     } catch (...) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39825       };
39826     }
39827   }
39828 }
39829
39830
39831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39832   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39833   SwigValueWrapper< Dali::Property > arg2 ;
39834   Dali::KeyFrames *arg3 = 0 ;
39835   Dali::Animation::Interpolation arg4 ;
39836   Dali::Property *argp2 ;
39837
39838   arg1 = (Dali::Animation *)jarg1;
39839   argp2 = (Dali::Property *)jarg2;
39840   if (!argp2) {
39841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39842     return ;
39843   }
39844   arg2 = *argp2;
39845   arg3 = (Dali::KeyFrames *)jarg3;
39846   if (!arg3) {
39847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39848     return ;
39849   }
39850   arg4 = (Dali::Animation::Interpolation)jarg4;
39851   {
39852     try {
39853       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39854     } catch (std::out_of_range& e) {
39855       {
39856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39857       };
39858     } catch (std::exception& e) {
39859       {
39860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39861       };
39862     } catch (...) {
39863       {
39864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39865       };
39866     }
39867   }
39868 }
39869
39870
39871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39872   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39873   SwigValueWrapper< Dali::Property > arg2 ;
39874   Dali::KeyFrames *arg3 = 0 ;
39875   Dali::AlphaFunction arg4 ;
39876   Dali::Property *argp2 ;
39877   Dali::AlphaFunction *argp4 ;
39878
39879   arg1 = (Dali::Animation *)jarg1;
39880   argp2 = (Dali::Property *)jarg2;
39881   if (!argp2) {
39882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39883     return ;
39884   }
39885   arg2 = *argp2;
39886   arg3 = (Dali::KeyFrames *)jarg3;
39887   if (!arg3) {
39888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39889     return ;
39890   }
39891   argp4 = (Dali::AlphaFunction *)jarg4;
39892   if (!argp4) {
39893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39894     return ;
39895   }
39896   arg4 = *argp4;
39897   {
39898     try {
39899       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39900     } catch (std::out_of_range& e) {
39901       {
39902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39903       };
39904     } catch (std::exception& e) {
39905       {
39906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39907       };
39908     } catch (...) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39911       };
39912     }
39913   }
39914 }
39915
39916
39917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39918   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39919   SwigValueWrapper< Dali::Property > arg2 ;
39920   Dali::KeyFrames *arg3 = 0 ;
39921   Dali::AlphaFunction arg4 ;
39922   Dali::Animation::Interpolation arg5 ;
39923   Dali::Property *argp2 ;
39924   Dali::AlphaFunction *argp4 ;
39925
39926   arg1 = (Dali::Animation *)jarg1;
39927   argp2 = (Dali::Property *)jarg2;
39928   if (!argp2) {
39929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39930     return ;
39931   }
39932   arg2 = *argp2;
39933   arg3 = (Dali::KeyFrames *)jarg3;
39934   if (!arg3) {
39935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39936     return ;
39937   }
39938   argp4 = (Dali::AlphaFunction *)jarg4;
39939   if (!argp4) {
39940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39941     return ;
39942   }
39943   arg4 = *argp4;
39944   arg5 = (Dali::Animation::Interpolation)jarg5;
39945   {
39946     try {
39947       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39948     } catch (std::out_of_range& e) {
39949       {
39950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39951       };
39952     } catch (std::exception& e) {
39953       {
39954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39955       };
39956     } catch (...) {
39957       {
39958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39959       };
39960     }
39961   }
39962 }
39963
39964
39965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39966   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39967   SwigValueWrapper< Dali::Property > arg2 ;
39968   Dali::KeyFrames *arg3 = 0 ;
39969   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39970   Dali::Property *argp2 ;
39971   Dali::TimePeriod *argp4 ;
39972
39973   arg1 = (Dali::Animation *)jarg1;
39974   argp2 = (Dali::Property *)jarg2;
39975   if (!argp2) {
39976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39977     return ;
39978   }
39979   arg2 = *argp2;
39980   arg3 = (Dali::KeyFrames *)jarg3;
39981   if (!arg3) {
39982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39983     return ;
39984   }
39985   argp4 = (Dali::TimePeriod *)jarg4;
39986   if (!argp4) {
39987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39988     return ;
39989   }
39990   arg4 = *argp4;
39991   {
39992     try {
39993       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39994     } catch (std::out_of_range& e) {
39995       {
39996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39997       };
39998     } catch (std::exception& e) {
39999       {
40000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40005       };
40006     }
40007   }
40008 }
40009
40010
40011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
40012   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40013   SwigValueWrapper< Dali::Property > arg2 ;
40014   Dali::KeyFrames *arg3 = 0 ;
40015   SwigValueWrapper< Dali::TimePeriod > arg4 ;
40016   Dali::Animation::Interpolation arg5 ;
40017   Dali::Property *argp2 ;
40018   Dali::TimePeriod *argp4 ;
40019
40020   arg1 = (Dali::Animation *)jarg1;
40021   argp2 = (Dali::Property *)jarg2;
40022   if (!argp2) {
40023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40024     return ;
40025   }
40026   arg2 = *argp2;
40027   arg3 = (Dali::KeyFrames *)jarg3;
40028   if (!arg3) {
40029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40030     return ;
40031   }
40032   argp4 = (Dali::TimePeriod *)jarg4;
40033   if (!argp4) {
40034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40035     return ;
40036   }
40037   arg4 = *argp4;
40038   arg5 = (Dali::Animation::Interpolation)jarg5;
40039   {
40040     try {
40041       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40042     } catch (std::out_of_range& e) {
40043       {
40044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40045       };
40046     } catch (std::exception& e) {
40047       {
40048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40049       };
40050     } catch (...) {
40051       {
40052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40053       };
40054     }
40055   }
40056 }
40057
40058
40059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40060   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40061   SwigValueWrapper< Dali::Property > arg2 ;
40062   Dali::KeyFrames *arg3 = 0 ;
40063   Dali::AlphaFunction arg4 ;
40064   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40065   Dali::Property *argp2 ;
40066   Dali::AlphaFunction *argp4 ;
40067   Dali::TimePeriod *argp5 ;
40068
40069   arg1 = (Dali::Animation *)jarg1;
40070   argp2 = (Dali::Property *)jarg2;
40071   if (!argp2) {
40072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40073     return ;
40074   }
40075   arg2 = *argp2;
40076   arg3 = (Dali::KeyFrames *)jarg3;
40077   if (!arg3) {
40078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40079     return ;
40080   }
40081   argp4 = (Dali::AlphaFunction *)jarg4;
40082   if (!argp4) {
40083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40084     return ;
40085   }
40086   arg4 = *argp4;
40087   argp5 = (Dali::TimePeriod *)jarg5;
40088   if (!argp5) {
40089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40090     return ;
40091   }
40092   arg5 = *argp5;
40093   {
40094     try {
40095       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40096     } catch (std::out_of_range& e) {
40097       {
40098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40099       };
40100     } catch (std::exception& e) {
40101       {
40102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40103       };
40104     } catch (...) {
40105       {
40106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40107       };
40108     }
40109   }
40110 }
40111
40112
40113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40114   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40115   SwigValueWrapper< Dali::Property > arg2 ;
40116   Dali::KeyFrames *arg3 = 0 ;
40117   Dali::AlphaFunction arg4 ;
40118   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40119   Dali::Animation::Interpolation arg6 ;
40120   Dali::Property *argp2 ;
40121   Dali::AlphaFunction *argp4 ;
40122   Dali::TimePeriod *argp5 ;
40123
40124   arg1 = (Dali::Animation *)jarg1;
40125   argp2 = (Dali::Property *)jarg2;
40126   if (!argp2) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40128     return ;
40129   }
40130   arg2 = *argp2;
40131   arg3 = (Dali::KeyFrames *)jarg3;
40132   if (!arg3) {
40133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40134     return ;
40135   }
40136   argp4 = (Dali::AlphaFunction *)jarg4;
40137   if (!argp4) {
40138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40139     return ;
40140   }
40141   arg4 = *argp4;
40142   argp5 = (Dali::TimePeriod *)jarg5;
40143   if (!argp5) {
40144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40145     return ;
40146   }
40147   arg5 = *argp5;
40148   arg6 = (Dali::Animation::Interpolation)jarg6;
40149   {
40150     try {
40151       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40152     } catch (std::out_of_range& e) {
40153       {
40154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40155       };
40156     } catch (std::exception& e) {
40157       {
40158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40159       };
40160     } catch (...) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40163       };
40164     }
40165   }
40166 }
40167
40168
40169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40170   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40171   Dali::Actor arg2 ;
40172   Dali::Path arg3 ;
40173   Dali::Vector3 *arg4 = 0 ;
40174   Dali::Actor *argp2 ;
40175   Dali::Path *argp3 ;
40176
40177   arg1 = (Dali::Animation *)jarg1;
40178   argp2 = (Dali::Actor *)jarg2;
40179   if (!argp2) {
40180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40181     return ;
40182   }
40183   arg2 = *argp2;
40184   argp3 = (Dali::Path *)jarg3;
40185   if (!argp3) {
40186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40187     return ;
40188   }
40189   arg3 = *argp3;
40190   arg4 = (Dali::Vector3 *)jarg4;
40191   if (!arg4) {
40192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40193     return ;
40194   }
40195   {
40196     try {
40197       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40198     } catch (std::out_of_range& e) {
40199       {
40200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40201       };
40202     } catch (std::exception& e) {
40203       {
40204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40205       };
40206     } catch (...) {
40207       {
40208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40209       };
40210     }
40211   }
40212 }
40213
40214
40215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40216   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40217   Dali::Actor arg2 ;
40218   Dali::Path arg3 ;
40219   Dali::Vector3 *arg4 = 0 ;
40220   Dali::AlphaFunction arg5 ;
40221   Dali::Actor *argp2 ;
40222   Dali::Path *argp3 ;
40223   Dali::AlphaFunction *argp5 ;
40224
40225   arg1 = (Dali::Animation *)jarg1;
40226   argp2 = (Dali::Actor *)jarg2;
40227   if (!argp2) {
40228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40229     return ;
40230   }
40231   arg2 = *argp2;
40232   argp3 = (Dali::Path *)jarg3;
40233   if (!argp3) {
40234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40235     return ;
40236   }
40237   arg3 = *argp3;
40238   arg4 = (Dali::Vector3 *)jarg4;
40239   if (!arg4) {
40240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40241     return ;
40242   }
40243   argp5 = (Dali::AlphaFunction *)jarg5;
40244   if (!argp5) {
40245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40246     return ;
40247   }
40248   arg5 = *argp5;
40249   {
40250     try {
40251       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40252     } catch (std::out_of_range& e) {
40253       {
40254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40255       };
40256     } catch (std::exception& e) {
40257       {
40258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40259       };
40260     } catch (...) {
40261       {
40262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40263       };
40264     }
40265   }
40266 }
40267
40268
40269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40270   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40271   Dali::Actor arg2 ;
40272   Dali::Path arg3 ;
40273   Dali::Vector3 *arg4 = 0 ;
40274   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40275   Dali::Actor *argp2 ;
40276   Dali::Path *argp3 ;
40277   Dali::TimePeriod *argp5 ;
40278
40279   arg1 = (Dali::Animation *)jarg1;
40280   argp2 = (Dali::Actor *)jarg2;
40281   if (!argp2) {
40282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40283     return ;
40284   }
40285   arg2 = *argp2;
40286   argp3 = (Dali::Path *)jarg3;
40287   if (!argp3) {
40288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40289     return ;
40290   }
40291   arg3 = *argp3;
40292   arg4 = (Dali::Vector3 *)jarg4;
40293   if (!arg4) {
40294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40295     return ;
40296   }
40297   argp5 = (Dali::TimePeriod *)jarg5;
40298   if (!argp5) {
40299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40300     return ;
40301   }
40302   arg5 = *argp5;
40303   {
40304     try {
40305       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40306     } catch (std::out_of_range& e) {
40307       {
40308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40309       };
40310     } catch (std::exception& e) {
40311       {
40312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (...) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40317       };
40318     }
40319   }
40320 }
40321
40322
40323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40324   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40325   Dali::Actor arg2 ;
40326   Dali::Path arg3 ;
40327   Dali::Vector3 *arg4 = 0 ;
40328   Dali::AlphaFunction arg5 ;
40329   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40330   Dali::Actor *argp2 ;
40331   Dali::Path *argp3 ;
40332   Dali::AlphaFunction *argp5 ;
40333   Dali::TimePeriod *argp6 ;
40334
40335   arg1 = (Dali::Animation *)jarg1;
40336   argp2 = (Dali::Actor *)jarg2;
40337   if (!argp2) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40339     return ;
40340   }
40341   arg2 = *argp2;
40342   argp3 = (Dali::Path *)jarg3;
40343   if (!argp3) {
40344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40345     return ;
40346   }
40347   arg3 = *argp3;
40348   arg4 = (Dali::Vector3 *)jarg4;
40349   if (!arg4) {
40350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40351     return ;
40352   }
40353   argp5 = (Dali::AlphaFunction *)jarg5;
40354   if (!argp5) {
40355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40356     return ;
40357   }
40358   arg5 = *argp5;
40359   argp6 = (Dali::TimePeriod *)jarg6;
40360   if (!argp6) {
40361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40362     return ;
40363   }
40364   arg6 = *argp6;
40365   {
40366     try {
40367       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40368     } catch (std::out_of_range& e) {
40369       {
40370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40371       };
40372     } catch (std::exception& e) {
40373       {
40374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40375       };
40376     } catch (...) {
40377       {
40378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40379       };
40380     }
40381   }
40382 }
40383
40384
40385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40386   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40387   Dali::Actor arg2 ;
40388   float arg3 ;
40389   Dali::Actor *argp2 ;
40390
40391   arg1 = (Dali::Animation *)jarg1;
40392   argp2 = (Dali::Actor *)jarg2;
40393   if (!argp2) {
40394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40395     return ;
40396   }
40397   arg2 = *argp2;
40398   arg3 = (float)jarg3;
40399   {
40400     try {
40401       (arg1)->Show(arg2,arg3);
40402     } catch (std::out_of_range& e) {
40403       {
40404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40405       };
40406     } catch (std::exception& e) {
40407       {
40408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40409       };
40410     } catch (...) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40413       };
40414     }
40415   }
40416 }
40417
40418
40419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40420   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40421   Dali::Actor arg2 ;
40422   float arg3 ;
40423   Dali::Actor *argp2 ;
40424
40425   arg1 = (Dali::Animation *)jarg1;
40426   argp2 = (Dali::Actor *)jarg2;
40427   if (!argp2) {
40428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40429     return ;
40430   }
40431   arg2 = *argp2;
40432   arg3 = (float)jarg3;
40433   {
40434     try {
40435       (arg1)->Hide(arg2,arg3);
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40443       };
40444     } catch (...) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40447       };
40448     }
40449   }
40450 }
40451
40452
40453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40454   int jresult ;
40455   int result;
40456
40457   result = (int)Dali::LinearConstrainer::Property::VALUE;
40458   jresult = (int)result;
40459   return jresult;
40460 }
40461
40462
40463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40464   int jresult ;
40465   int result;
40466
40467   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40468   jresult = (int)result;
40469   return jresult;
40470 }
40471
40472
40473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40474   void * jresult ;
40475   Dali::LinearConstrainer::Property *result = 0 ;
40476
40477   {
40478     try {
40479       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
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 = (void *)result;
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40500   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40501
40502   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40503   {
40504     try {
40505       delete arg1;
40506     } catch (std::out_of_range& e) {
40507       {
40508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40509       };
40510     } catch (std::exception& e) {
40511       {
40512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40513       };
40514     } catch (...) {
40515       {
40516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40517       };
40518     }
40519   }
40520 }
40521
40522
40523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40524   void * jresult ;
40525   Dali::LinearConstrainer result;
40526
40527   {
40528     try {
40529       result = Dali::LinearConstrainer::New();
40530     } catch (std::out_of_range& e) {
40531       {
40532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40533       };
40534     } catch (std::exception& e) {
40535       {
40536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40537       };
40538     } catch (...) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40541       };
40542     }
40543   }
40544   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40550   void * jresult ;
40551   Dali::BaseHandle arg1 ;
40552   Dali::BaseHandle *argp1 ;
40553   Dali::LinearConstrainer result;
40554
40555   argp1 = (Dali::BaseHandle *)jarg1;
40556   if (!argp1) {
40557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40558     return 0;
40559   }
40560   arg1 = *argp1;
40561   {
40562     try {
40563       result = Dali::LinearConstrainer::DownCast(arg1);
40564     } catch (std::out_of_range& e) {
40565       {
40566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40567       };
40568     } catch (std::exception& e) {
40569       {
40570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40571       };
40572     } catch (...) {
40573       {
40574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40575       };
40576     }
40577   }
40578   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40579   return jresult;
40580 }
40581
40582
40583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40584   void * jresult ;
40585   Dali::LinearConstrainer *result = 0 ;
40586
40587   {
40588     try {
40589       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40590     } catch (std::out_of_range& e) {
40591       {
40592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40593       };
40594     } catch (std::exception& e) {
40595       {
40596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40597       };
40598     } catch (...) {
40599       {
40600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40601       };
40602     }
40603   }
40604   jresult = (void *)result;
40605   return jresult;
40606 }
40607
40608
40609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40610   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40611
40612   arg1 = (Dali::LinearConstrainer *)jarg1;
40613   {
40614     try {
40615       delete arg1;
40616     } catch (std::out_of_range& e) {
40617       {
40618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40619       };
40620     } catch (std::exception& e) {
40621       {
40622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40623       };
40624     } catch (...) {
40625       {
40626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40627       };
40628     }
40629   }
40630 }
40631
40632
40633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40634   void * jresult ;
40635   Dali::LinearConstrainer *arg1 = 0 ;
40636   Dali::LinearConstrainer *result = 0 ;
40637
40638   arg1 = (Dali::LinearConstrainer *)jarg1;
40639   if (!arg1) {
40640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40641     return 0;
40642   }
40643   {
40644     try {
40645       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40646     } catch (std::out_of_range& e) {
40647       {
40648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40649       };
40650     } catch (std::exception& e) {
40651       {
40652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40653       };
40654     } catch (...) {
40655       {
40656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40657       };
40658     }
40659   }
40660   jresult = (void *)result;
40661   return jresult;
40662 }
40663
40664
40665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40666   void * jresult ;
40667   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40668   Dali::LinearConstrainer *arg2 = 0 ;
40669   Dali::LinearConstrainer *result = 0 ;
40670
40671   arg1 = (Dali::LinearConstrainer *)jarg1;
40672   arg2 = (Dali::LinearConstrainer *)jarg2;
40673   if (!arg2) {
40674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40675     return 0;
40676   }
40677   {
40678     try {
40679       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40680     } catch (std::out_of_range& e) {
40681       {
40682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40683       };
40684     } catch (std::exception& e) {
40685       {
40686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40687       };
40688     } catch (...) {
40689       {
40690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40691       };
40692     }
40693   }
40694   jresult = (void *)result;
40695   return jresult;
40696 }
40697
40698
40699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40700   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40701   SwigValueWrapper< Dali::Property > arg2 ;
40702   SwigValueWrapper< Dali::Property > arg3 ;
40703   Dali::Vector2 *arg4 = 0 ;
40704   Dali::Vector2 *arg5 = 0 ;
40705   Dali::Property *argp2 ;
40706   Dali::Property *argp3 ;
40707
40708   arg1 = (Dali::LinearConstrainer *)jarg1;
40709   argp2 = (Dali::Property *)jarg2;
40710   if (!argp2) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40712     return ;
40713   }
40714   arg2 = *argp2;
40715   argp3 = (Dali::Property *)jarg3;
40716   if (!argp3) {
40717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40718     return ;
40719   }
40720   arg3 = *argp3;
40721   arg4 = (Dali::Vector2 *)jarg4;
40722   if (!arg4) {
40723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40724     return ;
40725   }
40726   arg5 = (Dali::Vector2 *)jarg5;
40727   if (!arg5) {
40728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40729     return ;
40730   }
40731   {
40732     try {
40733       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40734     } catch (std::out_of_range& e) {
40735       {
40736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40737       };
40738     } catch (std::exception& e) {
40739       {
40740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40741       };
40742     } catch (...) {
40743       {
40744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40745       };
40746     }
40747   }
40748 }
40749
40750
40751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40752   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40753   SwigValueWrapper< Dali::Property > arg2 ;
40754   SwigValueWrapper< Dali::Property > arg3 ;
40755   Dali::Vector2 *arg4 = 0 ;
40756   Dali::Property *argp2 ;
40757   Dali::Property *argp3 ;
40758
40759   arg1 = (Dali::LinearConstrainer *)jarg1;
40760   argp2 = (Dali::Property *)jarg2;
40761   if (!argp2) {
40762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40763     return ;
40764   }
40765   arg2 = *argp2;
40766   argp3 = (Dali::Property *)jarg3;
40767   if (!argp3) {
40768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40769     return ;
40770   }
40771   arg3 = *argp3;
40772   arg4 = (Dali::Vector2 *)jarg4;
40773   if (!arg4) {
40774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40775     return ;
40776   }
40777   {
40778     try {
40779       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40780     } catch (std::out_of_range& e) {
40781       {
40782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40783       };
40784     } catch (std::exception& e) {
40785       {
40786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40787       };
40788     } catch (...) {
40789       {
40790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40791       };
40792     }
40793   }
40794 }
40795
40796
40797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40798   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40799   Dali::Handle *arg2 = 0 ;
40800
40801   arg1 = (Dali::LinearConstrainer *)jarg1;
40802   arg2 = (Dali::Handle *)jarg2;
40803   if (!arg2) {
40804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40805     return ;
40806   }
40807   {
40808     try {
40809       (arg1)->Remove(*arg2);
40810     } catch (std::out_of_range& e) {
40811       {
40812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40813       };
40814     } catch (std::exception& e) {
40815       {
40816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40817       };
40818     } catch (...) {
40819       {
40820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40821       };
40822     }
40823   }
40824 }
40825
40826
40827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40828   int jresult ;
40829   int result;
40830
40831   result = (int)Dali::PathConstrainer::Property::FORWARD;
40832   jresult = (int)result;
40833   return jresult;
40834 }
40835
40836
40837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40838   int jresult ;
40839   int result;
40840
40841   result = (int)Dali::PathConstrainer::Property::POINTS;
40842   jresult = (int)result;
40843   return jresult;
40844 }
40845
40846
40847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40848   int jresult ;
40849   int result;
40850
40851   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40852   jresult = (int)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40858   void * jresult ;
40859   Dali::PathConstrainer::Property *result = 0 ;
40860
40861   {
40862     try {
40863       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40864     } catch (std::out_of_range& e) {
40865       {
40866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40867       };
40868     } catch (std::exception& e) {
40869       {
40870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40871       };
40872     } catch (...) {
40873       {
40874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40875       };
40876     }
40877   }
40878   jresult = (void *)result;
40879   return jresult;
40880 }
40881
40882
40883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40884   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40885
40886   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40887   {
40888     try {
40889       delete arg1;
40890     } catch (std::out_of_range& e) {
40891       {
40892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40893       };
40894     } catch (std::exception& e) {
40895       {
40896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40897       };
40898     } catch (...) {
40899       {
40900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40901       };
40902     }
40903   }
40904 }
40905
40906
40907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40908   void * jresult ;
40909   Dali::PathConstrainer result;
40910
40911   {
40912     try {
40913       result = Dali::PathConstrainer::New();
40914     } catch (std::out_of_range& e) {
40915       {
40916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40917       };
40918     } catch (std::exception& e) {
40919       {
40920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40921       };
40922     } catch (...) {
40923       {
40924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40925       };
40926     }
40927   }
40928   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40929   return jresult;
40930 }
40931
40932
40933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40934   void * jresult ;
40935   Dali::BaseHandle arg1 ;
40936   Dali::BaseHandle *argp1 ;
40937   Dali::PathConstrainer result;
40938
40939   argp1 = (Dali::BaseHandle *)jarg1;
40940   if (!argp1) {
40941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40942     return 0;
40943   }
40944   arg1 = *argp1;
40945   {
40946     try {
40947       result = Dali::PathConstrainer::DownCast(arg1);
40948     } catch (std::out_of_range& e) {
40949       {
40950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40951       };
40952     } catch (std::exception& e) {
40953       {
40954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40955       };
40956     } catch (...) {
40957       {
40958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40959       };
40960     }
40961   }
40962   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40963   return jresult;
40964 }
40965
40966
40967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40968   void * jresult ;
40969   Dali::PathConstrainer *result = 0 ;
40970
40971   {
40972     try {
40973       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40974     } catch (std::out_of_range& e) {
40975       {
40976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40977       };
40978     } catch (std::exception& e) {
40979       {
40980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40981       };
40982     } catch (...) {
40983       {
40984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40985       };
40986     }
40987   }
40988   jresult = (void *)result;
40989   return jresult;
40990 }
40991
40992
40993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40994   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40995
40996   arg1 = (Dali::PathConstrainer *)jarg1;
40997   {
40998     try {
40999       delete arg1;
41000     } catch (std::out_of_range& e) {
41001       {
41002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41003       };
41004     } catch (std::exception& e) {
41005       {
41006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41007       };
41008     } catch (...) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41011       };
41012     }
41013   }
41014 }
41015
41016
41017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41018   void * jresult ;
41019   Dali::PathConstrainer *arg1 = 0 ;
41020   Dali::PathConstrainer *result = 0 ;
41021
41022   arg1 = (Dali::PathConstrainer *)jarg1;
41023   if (!arg1) {
41024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41025     return 0;
41026   }
41027   {
41028     try {
41029       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41030     } catch (std::out_of_range& e) {
41031       {
41032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (std::exception& e) {
41035       {
41036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044   jresult = (void *)result;
41045   return jresult;
41046 }
41047
41048
41049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41050   void * jresult ;
41051   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41052   Dali::PathConstrainer *arg2 = 0 ;
41053   Dali::PathConstrainer *result = 0 ;
41054
41055   arg1 = (Dali::PathConstrainer *)jarg1;
41056   arg2 = (Dali::PathConstrainer *)jarg2;
41057   if (!arg2) {
41058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41059     return 0;
41060   }
41061   {
41062     try {
41063       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = (void *)result;
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41084   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41085   SwigValueWrapper< Dali::Property > arg2 ;
41086   SwigValueWrapper< Dali::Property > arg3 ;
41087   Dali::Vector2 *arg4 = 0 ;
41088   Dali::Vector2 *arg5 = 0 ;
41089   Dali::Property *argp2 ;
41090   Dali::Property *argp3 ;
41091
41092   arg1 = (Dali::PathConstrainer *)jarg1;
41093   argp2 = (Dali::Property *)jarg2;
41094   if (!argp2) {
41095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41096     return ;
41097   }
41098   arg2 = *argp2;
41099   argp3 = (Dali::Property *)jarg3;
41100   if (!argp3) {
41101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41102     return ;
41103   }
41104   arg3 = *argp3;
41105   arg4 = (Dali::Vector2 *)jarg4;
41106   if (!arg4) {
41107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41108     return ;
41109   }
41110   arg5 = (Dali::Vector2 *)jarg5;
41111   if (!arg5) {
41112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41113     return ;
41114   }
41115   {
41116     try {
41117       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41118     } catch (std::out_of_range& e) {
41119       {
41120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41121       };
41122     } catch (std::exception& e) {
41123       {
41124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41125       };
41126     } catch (...) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41129       };
41130     }
41131   }
41132 }
41133
41134
41135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41136   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41137   SwigValueWrapper< Dali::Property > arg2 ;
41138   SwigValueWrapper< Dali::Property > arg3 ;
41139   Dali::Vector2 *arg4 = 0 ;
41140   Dali::Property *argp2 ;
41141   Dali::Property *argp3 ;
41142
41143   arg1 = (Dali::PathConstrainer *)jarg1;
41144   argp2 = (Dali::Property *)jarg2;
41145   if (!argp2) {
41146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41147     return ;
41148   }
41149   arg2 = *argp2;
41150   argp3 = (Dali::Property *)jarg3;
41151   if (!argp3) {
41152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41153     return ;
41154   }
41155   arg3 = *argp3;
41156   arg4 = (Dali::Vector2 *)jarg4;
41157   if (!arg4) {
41158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41159     return ;
41160   }
41161   {
41162     try {
41163       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41164     } catch (std::out_of_range& e) {
41165       {
41166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41167       };
41168     } catch (std::exception& e) {
41169       {
41170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41171       };
41172     } catch (...) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41175       };
41176     }
41177   }
41178 }
41179
41180
41181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41182   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41183   Dali::Handle *arg2 = 0 ;
41184
41185   arg1 = (Dali::PathConstrainer *)jarg1;
41186   arg2 = (Dali::Handle *)jarg2;
41187   if (!arg2) {
41188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41189     return ;
41190   }
41191   {
41192     try {
41193       (arg1)->Remove(*arg2);
41194     } catch (std::out_of_range& e) {
41195       {
41196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41197       };
41198     } catch (std::exception& e) {
41199       {
41200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41201       };
41202     } catch (...) {
41203       {
41204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41205       };
41206     }
41207   }
41208 }
41209
41210
41211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41212   int jresult ;
41213   Dali::FittingMode::Type result;
41214
41215   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41216   jresult = (int)result;
41217   return jresult;
41218 }
41219
41220
41221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41222   int jresult ;
41223   Dali::SamplingMode::Type result;
41224
41225   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41226   jresult = (int)result;
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41232   void * jresult ;
41233   Dali::BufferImage *result = 0 ;
41234
41235   {
41236     try {
41237       result = (Dali::BufferImage *)new Dali::BufferImage();
41238     } catch (std::out_of_range& e) {
41239       {
41240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41241       };
41242     } catch (std::exception& e) {
41243       {
41244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41245       };
41246     } catch (...) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41249       };
41250     }
41251   }
41252   jresult = (void *)result;
41253   return jresult;
41254 }
41255
41256
41257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41258   void * jresult ;
41259   unsigned int arg1 ;
41260   unsigned int arg2 ;
41261   Dali::Pixel::Format arg3 ;
41262   Dali::BufferImage result;
41263
41264   arg1 = (unsigned int)jarg1;
41265   arg2 = (unsigned int)jarg2;
41266   arg3 = (Dali::Pixel::Format)jarg3;
41267   {
41268     try {
41269       result = Dali::BufferImage::New(arg1,arg2,arg3);
41270     } catch (std::out_of_range& e) {
41271       {
41272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41273       };
41274     } catch (std::exception& e) {
41275       {
41276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41277       };
41278     } catch (...) {
41279       {
41280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41281       };
41282     }
41283   }
41284   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41285   return jresult;
41286 }
41287
41288
41289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41290   void * jresult ;
41291   unsigned int arg1 ;
41292   unsigned int arg2 ;
41293   Dali::BufferImage result;
41294
41295   arg1 = (unsigned int)jarg1;
41296   arg2 = (unsigned int)jarg2;
41297   {
41298     try {
41299       result = Dali::BufferImage::New(arg1,arg2);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41320   void * jresult ;
41321   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41322   unsigned int arg2 ;
41323   unsigned int arg3 ;
41324   Dali::Pixel::Format arg4 ;
41325   unsigned int arg5 ;
41326   Dali::BufferImage result;
41327
41328   arg1 = jarg1;
41329   arg2 = (unsigned int)jarg2;
41330   arg3 = (unsigned int)jarg3;
41331   arg4 = (Dali::Pixel::Format)jarg4;
41332   arg5 = (unsigned int)jarg5;
41333   {
41334     try {
41335       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41336     } catch (std::out_of_range& e) {
41337       {
41338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (std::exception& e) {
41341       {
41342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41351
41352
41353   return jresult;
41354 }
41355
41356
41357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41358   void * jresult ;
41359   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41360   unsigned int arg2 ;
41361   unsigned int arg3 ;
41362   Dali::Pixel::Format arg4 ;
41363   Dali::BufferImage result;
41364
41365   arg1 = jarg1;
41366   arg2 = (unsigned int)jarg2;
41367   arg3 = (unsigned int)jarg3;
41368   arg4 = (Dali::Pixel::Format)jarg4;
41369   {
41370     try {
41371       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41372     } catch (std::out_of_range& e) {
41373       {
41374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (std::exception& e) {
41377       {
41378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (...) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41383       };
41384     }
41385   }
41386   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41387
41388
41389   return jresult;
41390 }
41391
41392
41393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41394   void * jresult ;
41395   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41396   unsigned int arg2 ;
41397   unsigned int arg3 ;
41398   Dali::BufferImage result;
41399
41400   arg1 = jarg1;
41401   arg2 = (unsigned int)jarg2;
41402   arg3 = (unsigned int)jarg3;
41403   {
41404     try {
41405       result = Dali::BufferImage::New(arg1,arg2,arg3);
41406     } catch (std::out_of_range& e) {
41407       {
41408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (std::exception& e) {
41411       {
41412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (...) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41417       };
41418     }
41419   }
41420   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41421
41422
41423   return jresult;
41424 }
41425
41426
41427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41428   void * jresult ;
41429   Dali::BaseHandle arg1 ;
41430   Dali::BaseHandle *argp1 ;
41431   Dali::BufferImage result;
41432
41433   argp1 = (Dali::BaseHandle *)jarg1;
41434   if (!argp1) {
41435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41436     return 0;
41437   }
41438   arg1 = *argp1;
41439   {
41440     try {
41441       result = Dali::BufferImage::DownCast(arg1);
41442     } catch (std::out_of_range& e) {
41443       {
41444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41445       };
41446     } catch (std::exception& e) {
41447       {
41448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41449       };
41450     } catch (...) {
41451       {
41452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41453       };
41454     }
41455   }
41456   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41457   return jresult;
41458 }
41459
41460
41461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41462   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41463
41464   arg1 = (Dali::BufferImage *)jarg1;
41465   {
41466     try {
41467       delete arg1;
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41475       };
41476     } catch (...) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41479       };
41480     }
41481   }
41482 }
41483
41484
41485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41486   void * jresult ;
41487   Dali::BufferImage *arg1 = 0 ;
41488   Dali::BufferImage *result = 0 ;
41489
41490   arg1 = (Dali::BufferImage *)jarg1;
41491   if (!arg1) {
41492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41493     return 0;
41494   }
41495   {
41496     try {
41497       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41498     } catch (std::out_of_range& e) {
41499       {
41500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41501       };
41502     } catch (std::exception& e) {
41503       {
41504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (...) {
41507       {
41508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41509       };
41510     }
41511   }
41512   jresult = (void *)result;
41513   return jresult;
41514 }
41515
41516
41517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41518   void * jresult ;
41519   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41520   Dali::BufferImage *arg2 = 0 ;
41521   Dali::BufferImage *result = 0 ;
41522
41523   arg1 = (Dali::BufferImage *)jarg1;
41524   arg2 = (Dali::BufferImage *)jarg2;
41525   if (!arg2) {
41526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41527     return 0;
41528   }
41529   {
41530     try {
41531       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41532     } catch (std::out_of_range& e) {
41533       {
41534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41535       };
41536     } catch (std::exception& e) {
41537       {
41538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41539       };
41540     } catch (...) {
41541       {
41542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41543       };
41544     }
41545   }
41546   jresult = (void *)result;
41547   return jresult;
41548 }
41549
41550
41551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41552   void * jresult ;
41553   Dali::BufferImage result;
41554
41555   {
41556     try {
41557       result = Dali::BufferImage::WHITE();
41558     } catch (std::out_of_range& e) {
41559       {
41560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41561       };
41562     } catch (std::exception& e) {
41563       {
41564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41565       };
41566     } catch (...) {
41567       {
41568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41569       };
41570     }
41571   }
41572   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41573   return jresult;
41574 }
41575
41576
41577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41578   void * jresult ;
41579   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41580   Dali::PixelBuffer *result = 0 ;
41581
41582   arg1 = (Dali::BufferImage *)jarg1;
41583   {
41584     try {
41585       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41586     } catch (std::out_of_range& e) {
41587       {
41588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41589       };
41590     } catch (std::exception& e) {
41591       {
41592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41593       };
41594     } catch (...) {
41595       {
41596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41597       };
41598     }
41599   }
41600   jresult = (void *)result;
41601   return jresult;
41602 }
41603
41604
41605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41606   unsigned int jresult ;
41607   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41608   unsigned int result;
41609
41610   arg1 = (Dali::BufferImage *)jarg1;
41611   {
41612     try {
41613       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (...) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41625       };
41626     }
41627   }
41628   jresult = result;
41629   return jresult;
41630 }
41631
41632
41633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41634   unsigned int jresult ;
41635   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41636   unsigned int result;
41637
41638   arg1 = (Dali::BufferImage *)jarg1;
41639   {
41640     try {
41641       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41642     } catch (std::out_of_range& e) {
41643       {
41644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41645       };
41646     } catch (std::exception& e) {
41647       {
41648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41649       };
41650     } catch (...) {
41651       {
41652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41653       };
41654     }
41655   }
41656   jresult = result;
41657   return jresult;
41658 }
41659
41660
41661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41662   int jresult ;
41663   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41664   Dali::Pixel::Format result;
41665
41666   arg1 = (Dali::BufferImage *)jarg1;
41667   {
41668     try {
41669       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41670     } catch (std::out_of_range& e) {
41671       {
41672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41673       };
41674     } catch (std::exception& e) {
41675       {
41676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41677       };
41678     } catch (...) {
41679       {
41680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41681       };
41682     }
41683   }
41684   jresult = (int)result;
41685   return jresult;
41686 }
41687
41688
41689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41691
41692   arg1 = (Dali::BufferImage *)jarg1;
41693   {
41694     try {
41695       (arg1)->Update();
41696     } catch (std::out_of_range& e) {
41697       {
41698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41699       };
41700     } catch (std::exception& e) {
41701       {
41702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41703       };
41704     } catch (...) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41707       };
41708     }
41709   }
41710 }
41711
41712
41713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41714   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41715   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41716   Dali::RectArea *argp2 ;
41717
41718   arg1 = (Dali::BufferImage *)jarg1;
41719   argp2 = (Dali::RectArea *)jarg2;
41720   if (!argp2) {
41721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41722     return ;
41723   }
41724   arg2 = *argp2;
41725   {
41726     try {
41727       (arg1)->Update(arg2);
41728     } catch (std::out_of_range& e) {
41729       {
41730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41731       };
41732     } catch (std::exception& e) {
41733       {
41734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41735       };
41736     } catch (...) {
41737       {
41738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41739       };
41740     }
41741   }
41742 }
41743
41744
41745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41746   unsigned int jresult ;
41747   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41748   bool result;
41749
41750   arg1 = (Dali::BufferImage *)jarg1;
41751   {
41752     try {
41753       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41754     } catch (std::out_of_range& e) {
41755       {
41756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (std::exception& e) {
41759       {
41760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41761       };
41762     } catch (...) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41765       };
41766     }
41767   }
41768   jresult = result;
41769   return jresult;
41770 }
41771
41772
41773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41774   void * jresult ;
41775   Dali::EncodedBufferImage *result = 0 ;
41776
41777   {
41778     try {
41779       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41780     } catch (std::out_of_range& e) {
41781       {
41782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41783       };
41784     } catch (std::exception& e) {
41785       {
41786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41787       };
41788     } catch (...) {
41789       {
41790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41791       };
41792     }
41793   }
41794   jresult = (void *)result;
41795   return jresult;
41796 }
41797
41798
41799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41800   void * jresult ;
41801   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41802   std::size_t arg2 ;
41803   Dali::EncodedBufferImage result;
41804
41805   arg1 = (uint8_t *)jarg1;
41806   arg2 = (std::size_t)jarg2;
41807   {
41808     try {
41809       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41810     } catch (std::out_of_range& e) {
41811       {
41812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41813       };
41814     } catch (std::exception& e) {
41815       {
41816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (...) {
41819       {
41820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41821       };
41822     }
41823   }
41824   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41825   return jresult;
41826 }
41827
41828
41829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41830   void * jresult ;
41831   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41832   std::size_t arg2 ;
41833   Dali::ImageDimensions arg3 ;
41834   Dali::FittingMode::Type arg4 ;
41835   Dali::SamplingMode::Type arg5 ;
41836   bool arg6 ;
41837   Dali::ImageDimensions *argp3 ;
41838   Dali::EncodedBufferImage result;
41839
41840   arg1 = (uint8_t *)jarg1;
41841   arg2 = (std::size_t)jarg2;
41842   argp3 = (Dali::ImageDimensions *)jarg3;
41843   if (!argp3) {
41844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41845     return 0;
41846   }
41847   arg3 = *argp3;
41848   arg4 = (Dali::FittingMode::Type)jarg4;
41849   arg5 = (Dali::SamplingMode::Type)jarg5;
41850   arg6 = jarg6 ? true : false;
41851   {
41852     try {
41853       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41854     } catch (std::out_of_range& e) {
41855       {
41856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (std::exception& e) {
41859       {
41860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (...) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41865       };
41866     }
41867   }
41868   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41869   return jresult;
41870 }
41871
41872
41873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41874   void * jresult ;
41875   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41876   std::size_t arg2 ;
41877   Dali::ImageDimensions arg3 ;
41878   Dali::FittingMode::Type arg4 ;
41879   Dali::SamplingMode::Type arg5 ;
41880   Dali::ImageDimensions *argp3 ;
41881   Dali::EncodedBufferImage result;
41882
41883   arg1 = (uint8_t *)jarg1;
41884   arg2 = (std::size_t)jarg2;
41885   argp3 = (Dali::ImageDimensions *)jarg3;
41886   if (!argp3) {
41887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41888     return 0;
41889   }
41890   arg3 = *argp3;
41891   arg4 = (Dali::FittingMode::Type)jarg4;
41892   arg5 = (Dali::SamplingMode::Type)jarg5;
41893   {
41894     try {
41895       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41896     } catch (std::out_of_range& e) {
41897       {
41898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41899       };
41900     } catch (std::exception& e) {
41901       {
41902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41903       };
41904     } catch (...) {
41905       {
41906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41907       };
41908     }
41909   }
41910   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41911   return jresult;
41912 }
41913
41914
41915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41916   void * jresult ;
41917   Dali::BaseHandle arg1 ;
41918   Dali::BaseHandle *argp1 ;
41919   Dali::EncodedBufferImage result;
41920
41921   argp1 = (Dali::BaseHandle *)jarg1;
41922   if (!argp1) {
41923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41924     return 0;
41925   }
41926   arg1 = *argp1;
41927   {
41928     try {
41929       result = Dali::EncodedBufferImage::DownCast(arg1);
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (...) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41941       };
41942     }
41943   }
41944   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41945   return jresult;
41946 }
41947
41948
41949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41950   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41951
41952   arg1 = (Dali::EncodedBufferImage *)jarg1;
41953   {
41954     try {
41955       delete arg1;
41956     } catch (std::out_of_range& e) {
41957       {
41958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41959       };
41960     } catch (std::exception& e) {
41961       {
41962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41963       };
41964     } catch (...) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41967       };
41968     }
41969   }
41970 }
41971
41972
41973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41974   void * jresult ;
41975   Dali::EncodedBufferImage *arg1 = 0 ;
41976   Dali::EncodedBufferImage *result = 0 ;
41977
41978   arg1 = (Dali::EncodedBufferImage *)jarg1;
41979   if (!arg1) {
41980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41981     return 0;
41982   }
41983   {
41984     try {
41985       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41986     } catch (std::out_of_range& e) {
41987       {
41988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41989       };
41990     } catch (std::exception& e) {
41991       {
41992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41993       };
41994     } catch (...) {
41995       {
41996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41997       };
41998     }
41999   }
42000   jresult = (void *)result;
42001   return jresult;
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
42006   void * jresult ;
42007   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
42008   Dali::EncodedBufferImage *arg2 = 0 ;
42009   Dali::EncodedBufferImage *result = 0 ;
42010
42011   arg1 = (Dali::EncodedBufferImage *)jarg1;
42012   arg2 = (Dali::EncodedBufferImage *)jarg2;
42013   if (!arg2) {
42014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
42015     return 0;
42016   }
42017   {
42018     try {
42019       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42020     } catch (std::out_of_range& e) {
42021       {
42022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42023       };
42024     } catch (std::exception& e) {
42025       {
42026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42027       };
42028     } catch (...) {
42029       {
42030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42031       };
42032     }
42033   }
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42040   void * jresult ;
42041   Dali::NativeImage *result = 0 ;
42042
42043   {
42044     try {
42045       result = (Dali::NativeImage *)new Dali::NativeImage();
42046     } catch (std::out_of_range& e) {
42047       {
42048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42049       };
42050     } catch (std::exception& e) {
42051       {
42052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42053       };
42054     } catch (...) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42057       };
42058     }
42059   }
42060   jresult = (void *)result;
42061   return jresult;
42062 }
42063
42064
42065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42066   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42067
42068   arg1 = (Dali::NativeImage *)jarg1;
42069   {
42070     try {
42071       delete arg1;
42072     } catch (std::out_of_range& e) {
42073       {
42074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42075       };
42076     } catch (std::exception& e) {
42077       {
42078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42079       };
42080     } catch (...) {
42081       {
42082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42083       };
42084     }
42085   }
42086 }
42087
42088
42089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42090   void * jresult ;
42091   Dali::NativeImage *arg1 = 0 ;
42092   Dali::NativeImage *result = 0 ;
42093
42094   arg1 = (Dali::NativeImage *)jarg1;
42095   if (!arg1) {
42096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42097     return 0;
42098   }
42099   {
42100     try {
42101       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42102     } catch (std::out_of_range& e) {
42103       {
42104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42105       };
42106     } catch (std::exception& e) {
42107       {
42108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42109       };
42110     } catch (...) {
42111       {
42112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42113       };
42114     }
42115   }
42116   jresult = (void *)result;
42117   return jresult;
42118 }
42119
42120
42121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42122   void * jresult ;
42123   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42124   Dali::NativeImage *arg2 = 0 ;
42125   Dali::NativeImage *result = 0 ;
42126
42127   arg1 = (Dali::NativeImage *)jarg1;
42128   arg2 = (Dali::NativeImage *)jarg2;
42129   if (!arg2) {
42130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42131     return 0;
42132   }
42133   {
42134     try {
42135       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42136     } catch (std::out_of_range& e) {
42137       {
42138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42139       };
42140     } catch (std::exception& e) {
42141       {
42142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42143       };
42144     } catch (...) {
42145       {
42146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42147       };
42148     }
42149   }
42150   jresult = (void *)result;
42151   return jresult;
42152 }
42153
42154
42155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42156   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42157
42158   arg1 = (Dali::NativeImage *)jarg1;
42159   {
42160     try {
42161       (arg1)->CreateGlTexture();
42162     } catch (std::out_of_range& e) {
42163       {
42164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42165       };
42166     } catch (std::exception& e) {
42167       {
42168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42169       };
42170     } catch (...) {
42171       {
42172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42173       };
42174     }
42175   }
42176 }
42177
42178
42179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42180   void * jresult ;
42181   NativeImageInterface *arg1 = 0 ;
42182   Dali::NativeImage result;
42183
42184   arg1 = (NativeImageInterface *)jarg1;
42185   if (!arg1) {
42186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42187     return 0;
42188   }
42189   {
42190     try {
42191       result = Dali::NativeImage::New(*arg1);
42192     } catch (std::out_of_range& e) {
42193       {
42194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42195       };
42196     } catch (std::exception& e) {
42197       {
42198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42199       };
42200     } catch (...) {
42201       {
42202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42203       };
42204     }
42205   }
42206   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42212   void * jresult ;
42213   Dali::BaseHandle arg1 ;
42214   Dali::BaseHandle *argp1 ;
42215   Dali::NativeImage result;
42216
42217   argp1 = (Dali::BaseHandle *)jarg1;
42218   if (!argp1) {
42219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42220     return 0;
42221   }
42222   arg1 = *argp1;
42223   {
42224     try {
42225       result = Dali::NativeImage::DownCast(arg1);
42226     } catch (std::out_of_range& e) {
42227       {
42228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42229       };
42230     } catch (std::exception& e) {
42231       {
42232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42233       };
42234     } catch (...) {
42235       {
42236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42237       };
42238     }
42239   }
42240   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42241   return jresult;
42242 }
42243
42244
42245 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42246   char * jresult ;
42247   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42248   char *result = 0 ;
42249
42250   arg1 = (Dali::NativeImage *)jarg1;
42251   {
42252     try {
42253       result = (char *)(arg1)->GetCustomFragmentPreFix();
42254     } catch (std::out_of_range& e) {
42255       {
42256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42257       };
42258     } catch (std::exception& e) {
42259       {
42260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42261       };
42262     } catch (...) {
42263       {
42264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42265       };
42266     }
42267   }
42268   jresult = SWIG_csharp_string_callback((const char *)result);
42269   return jresult;
42270 }
42271
42272
42273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42274   char * jresult ;
42275   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42276   char *result = 0 ;
42277
42278   arg1 = (Dali::NativeImage *)jarg1;
42279   {
42280     try {
42281       result = (char *)(arg1)->GetCustomSamplerTypename();
42282     } catch (std::out_of_range& e) {
42283       {
42284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42285       };
42286     } catch (std::exception& e) {
42287       {
42288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42289       };
42290     } catch (...) {
42291       {
42292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42293       };
42294     }
42295   }
42296   jresult = SWIG_csharp_string_callback((const char *)result);
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42302   unsigned int jresult ;
42303   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42304   bool result;
42305
42306   arg1 = (Dali::NativeImageInterface *)jarg1;
42307   {
42308     try {
42309       result = (bool)(arg1)->GlExtensionCreate();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (...) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42321       };
42322     }
42323   }
42324   jresult = result;
42325   return jresult;
42326 }
42327
42328
42329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42331
42332   arg1 = (Dali::NativeImageInterface *)jarg1;
42333   {
42334     try {
42335       (arg1)->GlExtensionDestroy();
42336     } catch (std::out_of_range& e) {
42337       {
42338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42339       };
42340     } catch (std::exception& e) {
42341       {
42342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42343       };
42344     } catch (...) {
42345       {
42346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42347       };
42348     }
42349   }
42350 }
42351
42352
42353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42354   unsigned int jresult ;
42355   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42356   unsigned int result;
42357
42358   arg1 = (Dali::NativeImageInterface *)jarg1;
42359   {
42360     try {
42361       result = (unsigned int)(arg1)->TargetTexture();
42362     } catch (std::out_of_range& e) {
42363       {
42364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42365       };
42366     } catch (std::exception& e) {
42367       {
42368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42369       };
42370     } catch (...) {
42371       {
42372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42373       };
42374     }
42375   }
42376   jresult = result;
42377   return jresult;
42378 }
42379
42380
42381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42382   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42383
42384   arg1 = (Dali::NativeImageInterface *)jarg1;
42385   {
42386     try {
42387       (arg1)->PrepareTexture();
42388     } catch (std::out_of_range& e) {
42389       {
42390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42391       };
42392     } catch (std::exception& e) {
42393       {
42394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42395       };
42396     } catch (...) {
42397       {
42398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42399       };
42400     }
42401   }
42402 }
42403
42404
42405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42406   unsigned int jresult ;
42407   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42408   unsigned int result;
42409
42410   arg1 = (Dali::NativeImageInterface *)jarg1;
42411   {
42412     try {
42413       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42414     } catch (std::out_of_range& e) {
42415       {
42416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (std::exception& e) {
42419       {
42420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428   jresult = result;
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42434   unsigned int jresult ;
42435   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42436   unsigned int result;
42437
42438   arg1 = (Dali::NativeImageInterface *)jarg1;
42439   {
42440     try {
42441       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (...) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42453       };
42454     }
42455   }
42456   jresult = result;
42457   return jresult;
42458 }
42459
42460
42461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42462   unsigned int jresult ;
42463   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42464   bool result;
42465
42466   arg1 = (Dali::NativeImageInterface *)jarg1;
42467   {
42468     try {
42469       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42470     } catch (std::out_of_range& e) {
42471       {
42472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42473       };
42474     } catch (std::exception& e) {
42475       {
42476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42477       };
42478     } catch (...) {
42479       {
42480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42481       };
42482     }
42483   }
42484   jresult = result;
42485   return jresult;
42486 }
42487
42488
42489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42490   void * jresult ;
42491   std::string *arg1 = 0 ;
42492   Dali::ImageDimensions result;
42493
42494   if (!jarg1) {
42495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42496     return 0;
42497   }
42498   std::string arg1_str(jarg1);
42499   arg1 = &arg1_str;
42500   {
42501     try {
42502       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42503     } catch (std::out_of_range& e) {
42504       {
42505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42506       };
42507     } catch (std::exception& e) {
42508       {
42509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42510       };
42511     } catch (...) {
42512       {
42513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42514       };
42515     }
42516   }
42517   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42518
42519   //argout typemap for const std::string&
42520
42521   return jresult;
42522 }
42523
42524
42525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42526   void * jresult ;
42527   Dali::ResourceImage *result = 0 ;
42528
42529   {
42530     try {
42531       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42532     } catch (std::out_of_range& e) {
42533       {
42534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42535       };
42536     } catch (std::exception& e) {
42537       {
42538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (...) {
42541       {
42542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42543       };
42544     }
42545   }
42546   jresult = (void *)result;
42547   return jresult;
42548 }
42549
42550
42551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42552   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42553
42554   arg1 = (Dali::ResourceImage *)jarg1;
42555   {
42556     try {
42557       delete arg1;
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42565       };
42566     } catch (...) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42569       };
42570     }
42571   }
42572 }
42573
42574
42575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42576   void * jresult ;
42577   Dali::ResourceImage *arg1 = 0 ;
42578   Dali::ResourceImage *result = 0 ;
42579
42580   arg1 = (Dali::ResourceImage *)jarg1;
42581   if (!arg1) {
42582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42583     return 0;
42584   }
42585   {
42586     try {
42587       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42588     } catch (std::out_of_range& e) {
42589       {
42590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42591       };
42592     } catch (std::exception& e) {
42593       {
42594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42595       };
42596     } catch (...) {
42597       {
42598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42599       };
42600     }
42601   }
42602   jresult = (void *)result;
42603   return jresult;
42604 }
42605
42606
42607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42608   void * jresult ;
42609   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42610   Dali::ResourceImage *arg2 = 0 ;
42611   Dali::ResourceImage *result = 0 ;
42612
42613   arg1 = (Dali::ResourceImage *)jarg1;
42614   arg2 = (Dali::ResourceImage *)jarg2;
42615   if (!arg2) {
42616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42617     return 0;
42618   }
42619   {
42620     try {
42621       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42622     } catch (std::out_of_range& e) {
42623       {
42624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42625       };
42626     } catch (std::exception& e) {
42627       {
42628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42629       };
42630     } catch (...) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42633       };
42634     }
42635   }
42636   jresult = (void *)result;
42637   return jresult;
42638 }
42639
42640
42641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42642   void * jresult ;
42643   std::string *arg1 = 0 ;
42644   bool arg2 ;
42645   Dali::ResourceImage result;
42646
42647   if (!jarg1) {
42648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42649     return 0;
42650   }
42651   std::string arg1_str(jarg1);
42652   arg1 = &arg1_str;
42653   arg2 = jarg2 ? true : false;
42654   {
42655     try {
42656       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42657     } catch (std::out_of_range& e) {
42658       {
42659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (std::exception& e) {
42662       {
42663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42664       };
42665     } catch (...) {
42666       {
42667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42668       };
42669     }
42670   }
42671   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42672
42673   //argout typemap for const std::string&
42674
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42680   void * jresult ;
42681   std::string *arg1 = 0 ;
42682   Dali::ResourceImage result;
42683
42684   if (!jarg1) {
42685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42686     return 0;
42687   }
42688   std::string arg1_str(jarg1);
42689   arg1 = &arg1_str;
42690   {
42691     try {
42692       result = Dali::ResourceImage::New((std::string const &)*arg1);
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 = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42708
42709   //argout typemap for const std::string&
42710
42711   return jresult;
42712 }
42713
42714
42715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42716   void * jresult ;
42717   std::string *arg1 = 0 ;
42718   Dali::ImageDimensions arg2 ;
42719   Dali::FittingMode::Type arg3 ;
42720   Dali::SamplingMode::Type arg4 ;
42721   bool arg5 ;
42722   Dali::ImageDimensions *argp2 ;
42723   Dali::ResourceImage result;
42724
42725   if (!jarg1) {
42726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42727     return 0;
42728   }
42729   std::string arg1_str(jarg1);
42730   arg1 = &arg1_str;
42731   argp2 = (Dali::ImageDimensions *)jarg2;
42732   if (!argp2) {
42733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42734     return 0;
42735   }
42736   arg2 = *argp2;
42737   arg3 = (Dali::FittingMode::Type)jarg3;
42738   arg4 = (Dali::SamplingMode::Type)jarg4;
42739   arg5 = jarg5 ? true : false;
42740   {
42741     try {
42742       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42743     } catch (std::out_of_range& e) {
42744       {
42745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42746       };
42747     } catch (std::exception& e) {
42748       {
42749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42750       };
42751     } catch (...) {
42752       {
42753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42754       };
42755     }
42756   }
42757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42758
42759   //argout typemap for const std::string&
42760
42761   return jresult;
42762 }
42763
42764
42765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42766   void * jresult ;
42767   std::string *arg1 = 0 ;
42768   Dali::ImageDimensions arg2 ;
42769   Dali::FittingMode::Type arg3 ;
42770   Dali::SamplingMode::Type arg4 ;
42771   Dali::ImageDimensions *argp2 ;
42772   Dali::ResourceImage result;
42773
42774   if (!jarg1) {
42775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42776     return 0;
42777   }
42778   std::string arg1_str(jarg1);
42779   arg1 = &arg1_str;
42780   argp2 = (Dali::ImageDimensions *)jarg2;
42781   if (!argp2) {
42782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42783     return 0;
42784   }
42785   arg2 = *argp2;
42786   arg3 = (Dali::FittingMode::Type)jarg3;
42787   arg4 = (Dali::SamplingMode::Type)jarg4;
42788   {
42789     try {
42790       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42791     } catch (std::out_of_range& e) {
42792       {
42793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42794       };
42795     } catch (std::exception& e) {
42796       {
42797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (...) {
42800       {
42801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42802       };
42803     }
42804   }
42805   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42806
42807   //argout typemap for const std::string&
42808
42809   return jresult;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42814   void * jresult ;
42815   std::string *arg1 = 0 ;
42816   Dali::ImageDimensions arg2 ;
42817   Dali::FittingMode::Type arg3 ;
42818   Dali::ImageDimensions *argp2 ;
42819   Dali::ResourceImage result;
42820
42821   if (!jarg1) {
42822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42823     return 0;
42824   }
42825   std::string arg1_str(jarg1);
42826   arg1 = &arg1_str;
42827   argp2 = (Dali::ImageDimensions *)jarg2;
42828   if (!argp2) {
42829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42830     return 0;
42831   }
42832   arg2 = *argp2;
42833   arg3 = (Dali::FittingMode::Type)jarg3;
42834   {
42835     try {
42836       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42837     } catch (std::out_of_range& e) {
42838       {
42839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42840       };
42841     } catch (std::exception& e) {
42842       {
42843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42844       };
42845     } catch (...) {
42846       {
42847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42848       };
42849     }
42850   }
42851   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42852
42853   //argout typemap for const std::string&
42854
42855   return jresult;
42856 }
42857
42858
42859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42860   void * jresult ;
42861   std::string *arg1 = 0 ;
42862   Dali::ImageDimensions arg2 ;
42863   Dali::ImageDimensions *argp2 ;
42864   Dali::ResourceImage result;
42865
42866   if (!jarg1) {
42867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42868     return 0;
42869   }
42870   std::string arg1_str(jarg1);
42871   arg1 = &arg1_str;
42872   argp2 = (Dali::ImageDimensions *)jarg2;
42873   if (!argp2) {
42874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42875     return 0;
42876   }
42877   arg2 = *argp2;
42878   {
42879     try {
42880       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42881     } catch (std::out_of_range& e) {
42882       {
42883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (std::exception& e) {
42886       {
42887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42896
42897   //argout typemap for const std::string&
42898
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42904   void * jresult ;
42905   Dali::BaseHandle arg1 ;
42906   Dali::BaseHandle *argp1 ;
42907   Dali::ResourceImage result;
42908
42909   argp1 = (Dali::BaseHandle *)jarg1;
42910   if (!argp1) {
42911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42912     return 0;
42913   }
42914   arg1 = *argp1;
42915   {
42916     try {
42917       result = Dali::ResourceImage::DownCast(arg1);
42918     } catch (std::out_of_range& e) {
42919       {
42920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42921       };
42922     } catch (std::exception& e) {
42923       {
42924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (...) {
42927       {
42928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42929       };
42930     }
42931   }
42932   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42933   return jresult;
42934 }
42935
42936
42937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42938   int jresult ;
42939   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42940   Dali::LoadingState result;
42941
42942   arg1 = (Dali::ResourceImage *)jarg1;
42943   {
42944     try {
42945       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42946     } catch (std::out_of_range& e) {
42947       {
42948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42949       };
42950     } catch (std::exception& e) {
42951       {
42952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (...) {
42955       {
42956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42957       };
42958     }
42959   }
42960   jresult = (int)result;
42961   return jresult;
42962 }
42963
42964
42965 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42966   char * jresult ;
42967   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42968   std::string result;
42969
42970   arg1 = (Dali::ResourceImage *)jarg1;
42971   {
42972     try {
42973       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42974     } catch (std::out_of_range& e) {
42975       {
42976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42977       };
42978     } catch (std::exception& e) {
42979       {
42980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42981       };
42982     } catch (...) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42985       };
42986     }
42987   }
42988   jresult = SWIG_csharp_string_callback((&result)->c_str());
42989   return jresult;
42990 }
42991
42992
42993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42994   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42995
42996   arg1 = (Dali::ResourceImage *)jarg1;
42997   {
42998     try {
42999       (arg1)->Reload();
43000     } catch (std::out_of_range& e) {
43001       {
43002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43003       };
43004     } catch (std::exception& e) {
43005       {
43006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43007       };
43008     } catch (...) {
43009       {
43010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43011       };
43012     }
43013   }
43014 }
43015
43016
43017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43018   void * jresult ;
43019   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43020   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43021
43022   arg1 = (Dali::ResourceImage *)jarg1;
43023   {
43024     try {
43025       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
43026     } catch (std::out_of_range& e) {
43027       {
43028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43029       };
43030     } catch (std::exception& e) {
43031       {
43032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43037       };
43038     }
43039   }
43040   jresult = (void *)result;
43041   return jresult;
43042 }
43043
43044
43045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43046   void * jresult ;
43047   Dali::FrameBufferImage *result = 0 ;
43048
43049   {
43050     try {
43051       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43052     } catch (std::out_of_range& e) {
43053       {
43054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (std::exception& e) {
43057       {
43058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (...) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43063       };
43064     }
43065   }
43066   jresult = (void *)result;
43067   return jresult;
43068 }
43069
43070
43071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43072   void * jresult ;
43073   unsigned int arg1 ;
43074   unsigned int arg2 ;
43075   Dali::Pixel::Format arg3 ;
43076   Dali::RenderBuffer::Format arg4 ;
43077   Dali::FrameBufferImage result;
43078
43079   arg1 = (unsigned int)jarg1;
43080   arg2 = (unsigned int)jarg2;
43081   arg3 = (Dali::Pixel::Format)jarg3;
43082   arg4 = (Dali::RenderBuffer::Format)jarg4;
43083   {
43084     try {
43085       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (...) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43097       };
43098     }
43099   }
43100   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43101   return jresult;
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43106   void * jresult ;
43107   unsigned int arg1 ;
43108   unsigned int arg2 ;
43109   Dali::Pixel::Format arg3 ;
43110   Dali::FrameBufferImage result;
43111
43112   arg1 = (unsigned int)jarg1;
43113   arg2 = (unsigned int)jarg2;
43114   arg3 = (Dali::Pixel::Format)jarg3;
43115   {
43116     try {
43117       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43118     } catch (std::out_of_range& e) {
43119       {
43120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (std::exception& e) {
43123       {
43124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (...) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43129       };
43130     }
43131   }
43132   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43133   return jresult;
43134 }
43135
43136
43137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43138   void * jresult ;
43139   unsigned int arg1 ;
43140   unsigned int arg2 ;
43141   Dali::FrameBufferImage result;
43142
43143   arg1 = (unsigned int)jarg1;
43144   arg2 = (unsigned int)jarg2;
43145   {
43146     try {
43147       result = Dali::FrameBufferImage::New(arg1,arg2);
43148     } catch (std::out_of_range& e) {
43149       {
43150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43151       };
43152     } catch (std::exception& e) {
43153       {
43154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43155       };
43156     } catch (...) {
43157       {
43158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43159       };
43160     }
43161   }
43162   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43163   return jresult;
43164 }
43165
43166
43167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43168   void * jresult ;
43169   unsigned int arg1 ;
43170   Dali::FrameBufferImage result;
43171
43172   arg1 = (unsigned int)jarg1;
43173   {
43174     try {
43175       result = Dali::FrameBufferImage::New(arg1);
43176     } catch (std::out_of_range& e) {
43177       {
43178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43179       };
43180     } catch (std::exception& e) {
43181       {
43182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (...) {
43185       {
43186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43187       };
43188     }
43189   }
43190   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43191   return jresult;
43192 }
43193
43194
43195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43196   void * jresult ;
43197   Dali::FrameBufferImage result;
43198
43199   {
43200     try {
43201       result = Dali::FrameBufferImage::New();
43202     } catch (std::out_of_range& e) {
43203       {
43204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (std::exception& e) {
43207       {
43208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43222   void * jresult ;
43223   Dali::NativeImageInterface *arg1 = 0 ;
43224   Dali::FrameBufferImage result;
43225
43226   arg1 = (Dali::NativeImageInterface *)jarg1;
43227   if (!arg1) {
43228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43229     return 0;
43230   }
43231   {
43232     try {
43233       result = Dali::FrameBufferImage::New(*arg1);
43234     } catch (std::out_of_range& e) {
43235       {
43236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43237       };
43238     } catch (std::exception& e) {
43239       {
43240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43241       };
43242     } catch (...) {
43243       {
43244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43245       };
43246     }
43247   }
43248   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43249   return jresult;
43250 }
43251
43252
43253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43254   void * jresult ;
43255   Dali::BaseHandle arg1 ;
43256   Dali::BaseHandle *argp1 ;
43257   Dali::FrameBufferImage result;
43258
43259   argp1 = (Dali::BaseHandle *)jarg1;
43260   if (!argp1) {
43261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43262     return 0;
43263   }
43264   arg1 = *argp1;
43265   {
43266     try {
43267       result = Dali::FrameBufferImage::DownCast(arg1);
43268     } catch (std::out_of_range& e) {
43269       {
43270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43271       };
43272     } catch (std::exception& e) {
43273       {
43274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43275       };
43276     } catch (...) {
43277       {
43278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43279       };
43280     }
43281   }
43282   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43283   return jresult;
43284 }
43285
43286
43287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43288   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43289
43290   arg1 = (Dali::FrameBufferImage *)jarg1;
43291   {
43292     try {
43293       delete arg1;
43294     } catch (std::out_of_range& e) {
43295       {
43296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43297       };
43298     } catch (std::exception& e) {
43299       {
43300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43301       };
43302     } catch (...) {
43303       {
43304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43305       };
43306     }
43307   }
43308 }
43309
43310
43311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43312   void * jresult ;
43313   Dali::FrameBufferImage *arg1 = 0 ;
43314   Dali::FrameBufferImage *result = 0 ;
43315
43316   arg1 = (Dali::FrameBufferImage *)jarg1;
43317   if (!arg1) {
43318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43319     return 0;
43320   }
43321   {
43322     try {
43323       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43324     } catch (std::out_of_range& e) {
43325       {
43326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (std::exception& e) {
43329       {
43330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43331       };
43332     } catch (...) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43335       };
43336     }
43337   }
43338   jresult = (void *)result;
43339   return jresult;
43340 }
43341
43342
43343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43344   void * jresult ;
43345   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43346   Dali::FrameBufferImage *arg2 = 0 ;
43347   Dali::FrameBufferImage *result = 0 ;
43348
43349   arg1 = (Dali::FrameBufferImage *)jarg1;
43350   arg2 = (Dali::FrameBufferImage *)jarg2;
43351   if (!arg2) {
43352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43353     return 0;
43354   }
43355   {
43356     try {
43357       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43358     } catch (std::out_of_range& e) {
43359       {
43360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43361       };
43362     } catch (std::exception& e) {
43363       {
43364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43365       };
43366     } catch (...) {
43367       {
43368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43369       };
43370     }
43371   }
43372   jresult = (void *)result;
43373   return jresult;
43374 }
43375
43376
43377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43378   void * jresult ;
43379   Dali::NinePatchImage *result = 0 ;
43380
43381   {
43382     try {
43383       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43384     } catch (std::out_of_range& e) {
43385       {
43386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43387       };
43388     } catch (std::exception& e) {
43389       {
43390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43391       };
43392     } catch (...) {
43393       {
43394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43395       };
43396     }
43397   }
43398   jresult = (void *)result;
43399   return jresult;
43400 }
43401
43402
43403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43404   void * jresult ;
43405   std::string *arg1 = 0 ;
43406   Dali::NinePatchImage result;
43407
43408   if (!jarg1) {
43409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43410     return 0;
43411   }
43412   std::string arg1_str(jarg1);
43413   arg1 = &arg1_str;
43414   {
43415     try {
43416       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43417     } catch (std::out_of_range& e) {
43418       {
43419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43420       };
43421     } catch (std::exception& e) {
43422       {
43423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43424       };
43425     } catch (...) {
43426       {
43427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43428       };
43429     }
43430   }
43431   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43432
43433   //argout typemap for const std::string&
43434
43435   return jresult;
43436 }
43437
43438
43439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43440   void * jresult ;
43441   Dali::BaseHandle arg1 ;
43442   Dali::BaseHandle *argp1 ;
43443   Dali::NinePatchImage result;
43444
43445   argp1 = (Dali::BaseHandle *)jarg1;
43446   if (!argp1) {
43447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43448     return 0;
43449   }
43450   arg1 = *argp1;
43451   {
43452     try {
43453       result = Dali::NinePatchImage::DownCast(arg1);
43454     } catch (std::out_of_range& e) {
43455       {
43456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43457       };
43458     } catch (std::exception& e) {
43459       {
43460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43461       };
43462     } catch (...) {
43463       {
43464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43465       };
43466     }
43467   }
43468   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43469   return jresult;
43470 }
43471
43472
43473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43474   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43475
43476   arg1 = (Dali::NinePatchImage *)jarg1;
43477   {
43478     try {
43479       delete arg1;
43480     } catch (std::out_of_range& e) {
43481       {
43482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43483       };
43484     } catch (std::exception& e) {
43485       {
43486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43487       };
43488     } catch (...) {
43489       {
43490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43491       };
43492     }
43493   }
43494 }
43495
43496
43497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43498   void * jresult ;
43499   Dali::NinePatchImage *arg1 = 0 ;
43500   Dali::NinePatchImage *result = 0 ;
43501
43502   arg1 = (Dali::NinePatchImage *)jarg1;
43503   if (!arg1) {
43504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43505     return 0;
43506   }
43507   {
43508     try {
43509       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43510     } catch (std::out_of_range& e) {
43511       {
43512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43513       };
43514     } catch (std::exception& e) {
43515       {
43516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43517       };
43518     } catch (...) {
43519       {
43520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43521       };
43522     }
43523   }
43524   jresult = (void *)result;
43525   return jresult;
43526 }
43527
43528
43529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43530   void * jresult ;
43531   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43532   Dali::NinePatchImage *arg2 = 0 ;
43533   Dali::NinePatchImage *result = 0 ;
43534
43535   arg1 = (Dali::NinePatchImage *)jarg1;
43536   arg2 = (Dali::NinePatchImage *)jarg2;
43537   if (!arg2) {
43538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43539     return 0;
43540   }
43541   {
43542     try {
43543       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43544     } catch (std::out_of_range& e) {
43545       {
43546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43547       };
43548     } catch (std::exception& e) {
43549       {
43550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43551       };
43552     } catch (...) {
43553       {
43554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43555       };
43556     }
43557   }
43558   jresult = (void *)result;
43559   return jresult;
43560 }
43561
43562
43563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43564   void * jresult ;
43565   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43566   Dali::Vector4 result;
43567
43568   arg1 = (Dali::NinePatchImage *)jarg1;
43569   {
43570     try {
43571       result = (arg1)->GetStretchBorders();
43572     } catch (std::out_of_range& e) {
43573       {
43574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43575       };
43576     } catch (std::exception& e) {
43577       {
43578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43579       };
43580     } catch (...) {
43581       {
43582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43583       };
43584     }
43585   }
43586   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43587   return jresult;
43588 }
43589
43590
43591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43592   void * jresult ;
43593   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43594   Dali::NinePatchImage::StretchRanges *result = 0 ;
43595
43596   arg1 = (Dali::NinePatchImage *)jarg1;
43597   {
43598     try {
43599       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43600     } catch (std::out_of_range& e) {
43601       {
43602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43603       };
43604     } catch (std::exception& e) {
43605       {
43606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43607       };
43608     } catch (...) {
43609       {
43610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43611       };
43612     }
43613   }
43614   jresult = (void *)result;
43615   return jresult;
43616 }
43617
43618
43619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43620   void * jresult ;
43621   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43622   Dali::NinePatchImage::StretchRanges *result = 0 ;
43623
43624   arg1 = (Dali::NinePatchImage *)jarg1;
43625   {
43626     try {
43627       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43628     } catch (std::out_of_range& e) {
43629       {
43630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43631       };
43632     } catch (std::exception& e) {
43633       {
43634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43635       };
43636     } catch (...) {
43637       {
43638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43639       };
43640     }
43641   }
43642   jresult = (void *)result;
43643   return jresult;
43644 }
43645
43646
43647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43648   void * jresult ;
43649   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43650   Dali::Rect< int > result;
43651
43652   arg1 = (Dali::NinePatchImage *)jarg1;
43653   {
43654     try {
43655       result = (arg1)->GetChildRectangle();
43656     } catch (std::out_of_range& e) {
43657       {
43658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43659       };
43660     } catch (std::exception& e) {
43661       {
43662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (...) {
43665       {
43666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43667       };
43668     }
43669   }
43670   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43671   return jresult;
43672 }
43673
43674
43675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43676   void * jresult ;
43677   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43678   Dali::BufferImage result;
43679
43680   arg1 = (Dali::NinePatchImage *)jarg1;
43681   {
43682     try {
43683       result = (arg1)->CreateCroppedBufferImage();
43684     } catch (std::out_of_range& e) {
43685       {
43686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43687       };
43688     } catch (std::exception& e) {
43689       {
43690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43691       };
43692     } catch (...) {
43693       {
43694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43695       };
43696     }
43697   }
43698   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43699   return jresult;
43700 }
43701
43702
43703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43704   unsigned int jresult ;
43705   std::string *arg1 = 0 ;
43706   bool result;
43707
43708   if (!jarg1) {
43709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43710     return 0;
43711   }
43712   std::string arg1_str(jarg1);
43713   arg1 = &arg1_str;
43714   {
43715     try {
43716       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43717     } catch (std::out_of_range& e) {
43718       {
43719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43720       };
43721     } catch (std::exception& e) {
43722       {
43723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (...) {
43726       {
43727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43728       };
43729     }
43730   }
43731   jresult = result;
43732
43733   //argout typemap for const std::string&
43734
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43740   int jresult ;
43741   int result;
43742
43743   result = (int)Dali::CameraActor::Property::TYPE;
43744   jresult = (int)result;
43745   return jresult;
43746 }
43747
43748
43749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43750   int jresult ;
43751   int result;
43752
43753   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43754   jresult = (int)result;
43755   return jresult;
43756 }
43757
43758
43759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43760   int jresult ;
43761   int result;
43762
43763   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43764   jresult = (int)result;
43765   return jresult;
43766 }
43767
43768
43769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43770   int jresult ;
43771   int result;
43772
43773   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43774   jresult = (int)result;
43775   return jresult;
43776 }
43777
43778
43779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43780   int jresult ;
43781   int result;
43782
43783   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43784   jresult = (int)result;
43785   return jresult;
43786 }
43787
43788
43789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43790   int jresult ;
43791   int result;
43792
43793   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43794   jresult = (int)result;
43795   return jresult;
43796 }
43797
43798
43799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43800   int jresult ;
43801   int result;
43802
43803   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43804   jresult = (int)result;
43805   return jresult;
43806 }
43807
43808
43809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43810   int jresult ;
43811   int result;
43812
43813   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43814   jresult = (int)result;
43815   return jresult;
43816 }
43817
43818
43819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43820   int jresult ;
43821   int result;
43822
43823   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43824   jresult = (int)result;
43825   return jresult;
43826 }
43827
43828
43829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43830   int jresult ;
43831   int result;
43832
43833   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43834   jresult = (int)result;
43835   return jresult;
43836 }
43837
43838
43839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43840   int jresult ;
43841   int result;
43842
43843   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43844   jresult = (int)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43850   int jresult ;
43851   int result;
43852
43853   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43854   jresult = (int)result;
43855   return jresult;
43856 }
43857
43858
43859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43860   int jresult ;
43861   int result;
43862
43863   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43864   jresult = (int)result;
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43870   int jresult ;
43871   int result;
43872
43873   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43874   jresult = (int)result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43880   void * jresult ;
43881   Dali::CameraActor::Property *result = 0 ;
43882
43883   {
43884     try {
43885       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43886     } catch (std::out_of_range& e) {
43887       {
43888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43889       };
43890     } catch (std::exception& e) {
43891       {
43892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43893       };
43894     } catch (...) {
43895       {
43896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43897       };
43898     }
43899   }
43900   jresult = (void *)result;
43901   return jresult;
43902 }
43903
43904
43905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43906   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43907
43908   arg1 = (Dali::CameraActor::Property *)jarg1;
43909   {
43910     try {
43911       delete arg1;
43912     } catch (std::out_of_range& e) {
43913       {
43914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43915       };
43916     } catch (std::exception& e) {
43917       {
43918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43919       };
43920     } catch (...) {
43921       {
43922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43923       };
43924     }
43925   }
43926 }
43927
43928
43929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43930   void * jresult ;
43931   Dali::CameraActor *result = 0 ;
43932
43933   {
43934     try {
43935       result = (Dali::CameraActor *)new Dali::CameraActor();
43936     } catch (std::out_of_range& e) {
43937       {
43938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43939       };
43940     } catch (std::exception& e) {
43941       {
43942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43943       };
43944     } catch (...) {
43945       {
43946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43947       };
43948     }
43949   }
43950   jresult = (void *)result;
43951   return jresult;
43952 }
43953
43954
43955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43956   void * jresult ;
43957   Dali::CameraActor result;
43958
43959   {
43960     try {
43961       result = Dali::CameraActor::New();
43962     } catch (std::out_of_range& e) {
43963       {
43964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43965       };
43966     } catch (std::exception& e) {
43967       {
43968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43969       };
43970     } catch (...) {
43971       {
43972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43973       };
43974     }
43975   }
43976   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43977   return jresult;
43978 }
43979
43980
43981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43982   void * jresult ;
43983   Dali::Size *arg1 = 0 ;
43984   Dali::CameraActor result;
43985
43986   arg1 = (Dali::Size *)jarg1;
43987   if (!arg1) {
43988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43989     return 0;
43990   }
43991   {
43992     try {
43993       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43994     } catch (std::out_of_range& e) {
43995       {
43996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43997       };
43998     } catch (std::exception& e) {
43999       {
44000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44001       };
44002     } catch (...) {
44003       {
44004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44005       };
44006     }
44007   }
44008   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44009   return jresult;
44010 }
44011
44012
44013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44014   void * jresult ;
44015   Dali::BaseHandle arg1 ;
44016   Dali::BaseHandle *argp1 ;
44017   Dali::CameraActor result;
44018
44019   argp1 = (Dali::BaseHandle *)jarg1;
44020   if (!argp1) {
44021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44022     return 0;
44023   }
44024   arg1 = *argp1;
44025   {
44026     try {
44027       result = Dali::CameraActor::DownCast(arg1);
44028     } catch (std::out_of_range& e) {
44029       {
44030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44031       };
44032     } catch (std::exception& e) {
44033       {
44034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44035       };
44036     } catch (...) {
44037       {
44038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44039       };
44040     }
44041   }
44042   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44043   return jresult;
44044 }
44045
44046
44047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44048   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44049
44050   arg1 = (Dali::CameraActor *)jarg1;
44051   {
44052     try {
44053       delete arg1;
44054     } catch (std::out_of_range& e) {
44055       {
44056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44057       };
44058     } catch (std::exception& e) {
44059       {
44060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44061       };
44062     } catch (...) {
44063       {
44064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44065       };
44066     }
44067   }
44068 }
44069
44070
44071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44072   void * jresult ;
44073   Dali::CameraActor *arg1 = 0 ;
44074   Dali::CameraActor *result = 0 ;
44075
44076   arg1 = (Dali::CameraActor *)jarg1;
44077   if (!arg1) {
44078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44079     return 0;
44080   }
44081   {
44082     try {
44083       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44084     } catch (std::out_of_range& e) {
44085       {
44086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44087       };
44088     } catch (std::exception& e) {
44089       {
44090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44091       };
44092     } catch (...) {
44093       {
44094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44095       };
44096     }
44097   }
44098   jresult = (void *)result;
44099   return jresult;
44100 }
44101
44102
44103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44104   void * jresult ;
44105   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44106   Dali::CameraActor *arg2 = 0 ;
44107   Dali::CameraActor *result = 0 ;
44108
44109   arg1 = (Dali::CameraActor *)jarg1;
44110   arg2 = (Dali::CameraActor *)jarg2;
44111   if (!arg2) {
44112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44113     return 0;
44114   }
44115   {
44116     try {
44117       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44118     } catch (std::out_of_range& e) {
44119       {
44120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44121       };
44122     } catch (std::exception& e) {
44123       {
44124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44125       };
44126     } catch (...) {
44127       {
44128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44129       };
44130     }
44131   }
44132   jresult = (void *)result;
44133   return jresult;
44134 }
44135
44136
44137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44138   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44139   Dali::Camera::Type arg2 ;
44140
44141   arg1 = (Dali::CameraActor *)jarg1;
44142   arg2 = (Dali::Camera::Type)jarg2;
44143   {
44144     try {
44145       (arg1)->SetType(arg2);
44146     } catch (std::out_of_range& e) {
44147       {
44148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44149       };
44150     } catch (std::exception& e) {
44151       {
44152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44153       };
44154     } catch (...) {
44155       {
44156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44157       };
44158     }
44159   }
44160 }
44161
44162
44163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44164   int jresult ;
44165   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44166   Dali::Camera::Type result;
44167
44168   arg1 = (Dali::CameraActor *)jarg1;
44169   {
44170     try {
44171       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (...) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44183       };
44184     }
44185   }
44186   jresult = (int)result;
44187   return jresult;
44188 }
44189
44190
44191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44193   Dali::Camera::ProjectionMode arg2 ;
44194
44195   arg1 = (Dali::CameraActor *)jarg1;
44196   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44197   {
44198     try {
44199       (arg1)->SetProjectionMode(arg2);
44200     } catch (std::out_of_range& e) {
44201       {
44202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44203       };
44204     } catch (std::exception& e) {
44205       {
44206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44207       };
44208     } catch (...) {
44209       {
44210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44211       };
44212     }
44213   }
44214 }
44215
44216
44217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44218   int jresult ;
44219   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44220   Dali::Camera::ProjectionMode result;
44221
44222   arg1 = (Dali::CameraActor *)jarg1;
44223   {
44224     try {
44225       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44226     } catch (std::out_of_range& e) {
44227       {
44228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44229       };
44230     } catch (std::exception& e) {
44231       {
44232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44233       };
44234     } catch (...) {
44235       {
44236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44237       };
44238     }
44239   }
44240   jresult = (int)result;
44241   return jresult;
44242 }
44243
44244
44245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44246   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44247   float arg2 ;
44248
44249   arg1 = (Dali::CameraActor *)jarg1;
44250   arg2 = (float)jarg2;
44251   {
44252     try {
44253       (arg1)->SetFieldOfView(arg2);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44265       };
44266     }
44267   }
44268 }
44269
44270
44271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44272   float jresult ;
44273   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44274   float result;
44275
44276   arg1 = (Dali::CameraActor *)jarg1;
44277   {
44278     try {
44279       result = (float)(arg1)->GetFieldOfView();
44280     } catch (std::out_of_range& e) {
44281       {
44282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (std::exception& e) {
44285       {
44286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44287       };
44288     } catch (...) {
44289       {
44290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44291       };
44292     }
44293   }
44294   jresult = result;
44295   return jresult;
44296 }
44297
44298
44299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44300   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44301   float arg2 ;
44302
44303   arg1 = (Dali::CameraActor *)jarg1;
44304   arg2 = (float)jarg2;
44305   {
44306     try {
44307       (arg1)->SetAspectRatio(arg2);
44308     } catch (std::out_of_range& e) {
44309       {
44310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44311       };
44312     } catch (std::exception& e) {
44313       {
44314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44315       };
44316     } catch (...) {
44317       {
44318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44319       };
44320     }
44321   }
44322 }
44323
44324
44325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44326   float jresult ;
44327   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44328   float result;
44329
44330   arg1 = (Dali::CameraActor *)jarg1;
44331   {
44332     try {
44333       result = (float)(arg1)->GetAspectRatio();
44334     } catch (std::out_of_range& e) {
44335       {
44336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44337       };
44338     } catch (std::exception& e) {
44339       {
44340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44341       };
44342     } catch (...) {
44343       {
44344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44345       };
44346     }
44347   }
44348   jresult = result;
44349   return jresult;
44350 }
44351
44352
44353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44354   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44355   float arg2 ;
44356
44357   arg1 = (Dali::CameraActor *)jarg1;
44358   arg2 = (float)jarg2;
44359   {
44360     try {
44361       (arg1)->SetNearClippingPlane(arg2);
44362     } catch (std::out_of_range& e) {
44363       {
44364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44365       };
44366     } catch (std::exception& e) {
44367       {
44368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44369       };
44370     } catch (...) {
44371       {
44372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44373       };
44374     }
44375   }
44376 }
44377
44378
44379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44380   float jresult ;
44381   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44382   float result;
44383
44384   arg1 = (Dali::CameraActor *)jarg1;
44385   {
44386     try {
44387       result = (float)(arg1)->GetNearClippingPlane();
44388     } catch (std::out_of_range& e) {
44389       {
44390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44391       };
44392     } catch (std::exception& e) {
44393       {
44394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (...) {
44397       {
44398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44399       };
44400     }
44401   }
44402   jresult = result;
44403   return jresult;
44404 }
44405
44406
44407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44408   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44409   float arg2 ;
44410
44411   arg1 = (Dali::CameraActor *)jarg1;
44412   arg2 = (float)jarg2;
44413   {
44414     try {
44415       (arg1)->SetFarClippingPlane(arg2);
44416     } catch (std::out_of_range& e) {
44417       {
44418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44419       };
44420     } catch (std::exception& e) {
44421       {
44422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44427       };
44428     }
44429   }
44430 }
44431
44432
44433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44434   float jresult ;
44435   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44436   float result;
44437
44438   arg1 = (Dali::CameraActor *)jarg1;
44439   {
44440     try {
44441       result = (float)(arg1)->GetFarClippingPlane();
44442     } catch (std::out_of_range& e) {
44443       {
44444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44445       };
44446     } catch (std::exception& e) {
44447       {
44448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44449       };
44450     } catch (...) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44453       };
44454     }
44455   }
44456   jresult = result;
44457   return jresult;
44458 }
44459
44460
44461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44462   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44463   Dali::Vector3 *arg2 = 0 ;
44464
44465   arg1 = (Dali::CameraActor *)jarg1;
44466   arg2 = (Dali::Vector3 *)jarg2;
44467   if (!arg2) {
44468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44469     return ;
44470   }
44471   {
44472     try {
44473       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44474     } catch (std::out_of_range& e) {
44475       {
44476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (std::exception& e) {
44479       {
44480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44481       };
44482     } catch (...) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44485       };
44486     }
44487   }
44488 }
44489
44490
44491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44492   void * jresult ;
44493   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44494   Dali::Vector3 result;
44495
44496   arg1 = (Dali::CameraActor *)jarg1;
44497   {
44498     try {
44499       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44500     } catch (std::out_of_range& e) {
44501       {
44502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44503       };
44504     } catch (std::exception& e) {
44505       {
44506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44507       };
44508     } catch (...) {
44509       {
44510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44511       };
44512     }
44513   }
44514   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44515   return jresult;
44516 }
44517
44518
44519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44520   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44521   bool arg2 ;
44522
44523   arg1 = (Dali::CameraActor *)jarg1;
44524   arg2 = jarg2 ? true : false;
44525   {
44526     try {
44527       (arg1)->SetInvertYAxis(arg2);
44528     } catch (std::out_of_range& e) {
44529       {
44530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44531       };
44532     } catch (std::exception& e) {
44533       {
44534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44535       };
44536     } catch (...) {
44537       {
44538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44539       };
44540     }
44541   }
44542 }
44543
44544
44545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44546   unsigned int jresult ;
44547   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44548   bool result;
44549
44550   arg1 = (Dali::CameraActor *)jarg1;
44551   {
44552     try {
44553       result = (bool)(arg1)->GetInvertYAxis();
44554     } catch (std::out_of_range& e) {
44555       {
44556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44557       };
44558     } catch (std::exception& e) {
44559       {
44560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44561       };
44562     } catch (...) {
44563       {
44564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44565       };
44566     }
44567   }
44568   jresult = result;
44569   return jresult;
44570 }
44571
44572
44573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44574   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44575   Dali::Size *arg2 = 0 ;
44576
44577   arg1 = (Dali::CameraActor *)jarg1;
44578   arg2 = (Dali::Size *)jarg2;
44579   if (!arg2) {
44580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44581     return ;
44582   }
44583   {
44584     try {
44585       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44586     } catch (std::out_of_range& e) {
44587       {
44588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44589       };
44590     } catch (std::exception& e) {
44591       {
44592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44593       };
44594     } catch (...) {
44595       {
44596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44597       };
44598     }
44599   }
44600 }
44601
44602
44603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44604   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44605   Dali::Size *arg2 = 0 ;
44606
44607   arg1 = (Dali::CameraActor *)jarg1;
44608   arg2 = (Dali::Size *)jarg2;
44609   if (!arg2) {
44610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44611     return ;
44612   }
44613   {
44614     try {
44615       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44616     } catch (std::out_of_range& e) {
44617       {
44618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44619       };
44620     } catch (std::exception& e) {
44621       {
44622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44623       };
44624     } catch (...) {
44625       {
44626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44627       };
44628     }
44629   }
44630 }
44631
44632
44633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44634   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44635   float arg2 ;
44636   float arg3 ;
44637   float arg4 ;
44638   float arg5 ;
44639   float arg6 ;
44640   float arg7 ;
44641
44642   arg1 = (Dali::CameraActor *)jarg1;
44643   arg2 = (float)jarg2;
44644   arg3 = (float)jarg3;
44645   arg4 = (float)jarg4;
44646   arg5 = (float)jarg5;
44647   arg6 = (float)jarg6;
44648   arg7 = (float)jarg7;
44649   {
44650     try {
44651       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44652     } catch (std::out_of_range& e) {
44653       {
44654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44655       };
44656     } catch (std::exception& e) {
44657       {
44658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44659       };
44660     } catch (...) {
44661       {
44662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44663       };
44664     }
44665   }
44666 }
44667
44668
44669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44670   void * jresult ;
44671   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44672
44673   {
44674     try {
44675       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44676     } catch (std::out_of_range& e) {
44677       {
44678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (std::exception& e) {
44681       {
44682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44683       };
44684     } catch (...) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44687       };
44688     }
44689   }
44690   jresult = (void *)result;
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44696   void * jresult ;
44697   std::string arg1 ;
44698   Dali::Property::Value arg2 ;
44699   Dali::Property::Value *argp2 ;
44700   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44701
44702   if (!jarg1) {
44703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44704     return 0;
44705   }
44706   (&arg1)->assign(jarg1);
44707   argp2 = (Dali::Property::Value *)jarg2;
44708   if (!argp2) {
44709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44710     return 0;
44711   }
44712   arg2 = *argp2;
44713   {
44714     try {
44715       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44716     } catch (std::out_of_range& e) {
44717       {
44718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44719       };
44720     } catch (std::exception& e) {
44721       {
44722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44723       };
44724     } catch (...) {
44725       {
44726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44727       };
44728     }
44729   }
44730   jresult = (void *)result;
44731   return jresult;
44732 }
44733
44734
44735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44736   void * jresult ;
44737   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44738   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44739
44740   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44741   if (!arg1) {
44742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44743     return 0;
44744   }
44745   {
44746     try {
44747       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);
44748     } catch (std::out_of_range& e) {
44749       {
44750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (std::exception& e) {
44753       {
44754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762   jresult = (void *)result;
44763   return jresult;
44764 }
44765
44766
44767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44768   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44769   std::string *arg2 = 0 ;
44770
44771   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44772   if (!jarg2) {
44773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44774     return ;
44775   }
44776   std::string arg2_str(jarg2);
44777   arg2 = &arg2_str;
44778   if (arg1) (arg1)->first = *arg2;
44779
44780   //argout typemap for const std::string&
44781
44782 }
44783
44784
44785 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44786   char * jresult ;
44787   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44788   std::string *result = 0 ;
44789
44790   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44791   result = (std::string *) & ((arg1)->first);
44792   jresult = SWIG_csharp_string_callback(result->c_str());
44793   return jresult;
44794 }
44795
44796
44797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44798   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44799   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44800
44801   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44802   arg2 = (Dali::Property::Value *)jarg2;
44803   if (arg1) (arg1)->second = *arg2;
44804 }
44805
44806
44807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44808   void * jresult ;
44809   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44810   Dali::Property::Value *result = 0 ;
44811
44812   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44813   result = (Dali::Property::Value *)& ((arg1)->second);
44814   jresult = (void *)result;
44815   return jresult;
44816 }
44817
44818
44819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44820   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44821
44822   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44823   {
44824     try {
44825       delete arg1;
44826     } catch (std::out_of_range& e) {
44827       {
44828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (std::exception& e) {
44831       {
44832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840 }
44841
44842
44843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44844   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44845
44846   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44847   {
44848     try {
44849       (arg1)->clear();
44850     } catch (std::out_of_range& e) {
44851       {
44852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44853       };
44854     } catch (std::exception& e) {
44855       {
44856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44857       };
44858     } catch (...) {
44859       {
44860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44861       };
44862     }
44863   }
44864 }
44865
44866
44867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44868   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44869   Dali::TouchPoint *arg2 = 0 ;
44870
44871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44872   arg2 = (Dali::TouchPoint *)jarg2;
44873   if (!arg2) {
44874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44875     return ;
44876   }
44877   {
44878     try {
44879       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44880     } catch (std::out_of_range& e) {
44881       {
44882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44883       };
44884     } catch (std::exception& e) {
44885       {
44886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44887       };
44888     } catch (...) {
44889       {
44890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44891       };
44892     }
44893   }
44894 }
44895
44896
44897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44898   unsigned long jresult ;
44899   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44900   std::vector< Dali::TouchPoint >::size_type result;
44901
44902   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44903   {
44904     try {
44905       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44906     } catch (std::out_of_range& e) {
44907       {
44908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44909       };
44910     } catch (std::exception& e) {
44911       {
44912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44913       };
44914     } catch (...) {
44915       {
44916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44917       };
44918     }
44919   }
44920   jresult = (unsigned long)result;
44921   return jresult;
44922 }
44923
44924
44925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44926   unsigned long jresult ;
44927   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44928   std::vector< Dali::TouchPoint >::size_type result;
44929
44930   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44931   {
44932     try {
44933       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (...) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44945       };
44946     }
44947   }
44948   jresult = (unsigned long)result;
44949   return jresult;
44950 }
44951
44952
44953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44954   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44955   std::vector< Dali::TouchPoint >::size_type arg2 ;
44956
44957   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44958   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44959   {
44960     try {
44961       (arg1)->reserve(arg2);
44962     } catch (std::out_of_range& e) {
44963       {
44964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44965       };
44966     } catch (std::exception& e) {
44967       {
44968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44969       };
44970     } catch (...) {
44971       {
44972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44973       };
44974     }
44975   }
44976 }
44977
44978
44979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44980   void * jresult ;
44981   std::vector< Dali::TouchPoint > *result = 0 ;
44982
44983   {
44984     try {
44985       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44986     } catch (std::out_of_range& e) {
44987       {
44988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44989       };
44990     } catch (std::exception& e) {
44991       {
44992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44993       };
44994     } catch (...) {
44995       {
44996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44997       };
44998     }
44999   }
45000   jresult = (void *)result;
45001   return jresult;
45002 }
45003
45004
45005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45006   void * jresult ;
45007   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45008   std::vector< Dali::TouchPoint > *result = 0 ;
45009
45010   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45011   if (!arg1) {
45012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45013     return 0;
45014   }
45015   {
45016     try {
45017       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45018     } catch (std::out_of_range& e) {
45019       {
45020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45021       };
45022     } catch (std::exception& e) {
45023       {
45024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45025       };
45026     } catch (...) {
45027       {
45028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45029       };
45030     }
45031   }
45032   jresult = (void *)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45038   void * jresult ;
45039   int arg1 ;
45040   std::vector< Dali::TouchPoint > *result = 0 ;
45041
45042   arg1 = (int)jarg1;
45043   {
45044     try {
45045       try {
45046         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45047       }
45048       catch(std::out_of_range &_e) {
45049         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45050         return 0;
45051       }
45052
45053     } catch (std::out_of_range& e) {
45054       {
45055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45056       };
45057     } catch (std::exception& e) {
45058       {
45059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45060       };
45061     } catch (...) {
45062       {
45063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45064       };
45065     }
45066   }
45067   jresult = (void *)result;
45068   return jresult;
45069 }
45070
45071
45072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45073   void * jresult ;
45074   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45075   int arg2 ;
45076   SwigValueWrapper< Dali::TouchPoint > result;
45077
45078   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45079   arg2 = (int)jarg2;
45080   {
45081     try {
45082       try {
45083         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45084       }
45085       catch(std::out_of_range &_e) {
45086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45087         return 0;
45088       }
45089
45090     } catch (std::out_of_range& e) {
45091       {
45092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45093       };
45094     } catch (std::exception& e) {
45095       {
45096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45097       };
45098     } catch (...) {
45099       {
45100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45101       };
45102     }
45103   }
45104   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45105   return jresult;
45106 }
45107
45108
45109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45110   void * jresult ;
45111   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45112   int arg2 ;
45113   Dali::TouchPoint *result = 0 ;
45114
45115   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45116   arg2 = (int)jarg2;
45117   {
45118     try {
45119       try {
45120         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45121       }
45122       catch(std::out_of_range &_e) {
45123         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45124         return 0;
45125       }
45126
45127     } catch (std::out_of_range& e) {
45128       {
45129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45130       };
45131     } catch (std::exception& e) {
45132       {
45133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45134       };
45135     } catch (...) {
45136       {
45137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45138       };
45139     }
45140   }
45141   jresult = (void *)result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45147   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45148   int arg2 ;
45149   Dali::TouchPoint *arg3 = 0 ;
45150
45151   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45152   arg2 = (int)jarg2;
45153   arg3 = (Dali::TouchPoint *)jarg3;
45154   if (!arg3) {
45155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45156     return ;
45157   }
45158   {
45159     try {
45160       try {
45161         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45162       }
45163       catch(std::out_of_range &_e) {
45164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45165         return ;
45166       }
45167
45168     } catch (std::out_of_range& e) {
45169       {
45170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45171       };
45172     } catch (std::exception& e) {
45173       {
45174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45175       };
45176     } catch (...) {
45177       {
45178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45179       };
45180     }
45181   }
45182 }
45183
45184
45185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45186   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45187   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45188
45189   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45190   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45191   if (!arg2) {
45192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45193     return ;
45194   }
45195   {
45196     try {
45197       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45198     } catch (std::out_of_range& e) {
45199       {
45200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45201       };
45202     } catch (std::exception& e) {
45203       {
45204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45209       };
45210     }
45211   }
45212 }
45213
45214
45215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45216   void * jresult ;
45217   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45218   int arg2 ;
45219   int arg3 ;
45220   std::vector< Dali::TouchPoint > *result = 0 ;
45221
45222   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45223   arg2 = (int)jarg2;
45224   arg3 = (int)jarg3;
45225   {
45226     try {
45227       try {
45228         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45229       }
45230       catch(std::out_of_range &_e) {
45231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45232         return 0;
45233       }
45234       catch(std::invalid_argument &_e) {
45235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45236         return 0;
45237       }
45238
45239     } catch (std::out_of_range& e) {
45240       {
45241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (std::exception& e) {
45244       {
45245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253   jresult = (void *)result;
45254   return jresult;
45255 }
45256
45257
45258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45259   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45260   int arg2 ;
45261   Dali::TouchPoint *arg3 = 0 ;
45262
45263   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45264   arg2 = (int)jarg2;
45265   arg3 = (Dali::TouchPoint *)jarg3;
45266   if (!arg3) {
45267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45268     return ;
45269   }
45270   {
45271     try {
45272       try {
45273         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45274       }
45275       catch(std::out_of_range &_e) {
45276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45277         return ;
45278       }
45279
45280     } catch (std::out_of_range& e) {
45281       {
45282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45283       };
45284     } catch (std::exception& e) {
45285       {
45286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45287       };
45288     } catch (...) {
45289       {
45290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45291       };
45292     }
45293   }
45294 }
45295
45296
45297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45298   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45299   int arg2 ;
45300   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45301
45302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45303   arg2 = (int)jarg2;
45304   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45305   if (!arg3) {
45306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45307     return ;
45308   }
45309   {
45310     try {
45311       try {
45312         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45313       }
45314       catch(std::out_of_range &_e) {
45315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45316         return ;
45317       }
45318
45319     } catch (std::out_of_range& e) {
45320       {
45321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45322       };
45323     } catch (std::exception& e) {
45324       {
45325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45326       };
45327     } catch (...) {
45328       {
45329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45330       };
45331     }
45332   }
45333 }
45334
45335
45336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45337   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45338   int arg2 ;
45339
45340   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45341   arg2 = (int)jarg2;
45342   {
45343     try {
45344       try {
45345         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45346       }
45347       catch(std::out_of_range &_e) {
45348         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45349         return ;
45350       }
45351
45352     } catch (std::out_of_range& e) {
45353       {
45354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45355       };
45356     } catch (std::exception& e) {
45357       {
45358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45359       };
45360     } catch (...) {
45361       {
45362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45363       };
45364     }
45365   }
45366 }
45367
45368
45369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45370   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45371   int arg2 ;
45372   int arg3 ;
45373
45374   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45375   arg2 = (int)jarg2;
45376   arg3 = (int)jarg3;
45377   {
45378     try {
45379       try {
45380         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45381       }
45382       catch(std::out_of_range &_e) {
45383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45384         return ;
45385       }
45386       catch(std::invalid_argument &_e) {
45387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45388         return ;
45389       }
45390
45391     } catch (std::out_of_range& e) {
45392       {
45393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45394       };
45395     } catch (std::exception& e) {
45396       {
45397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45398       };
45399     } catch (...) {
45400       {
45401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45402       };
45403     }
45404   }
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45409   void * jresult ;
45410   Dali::TouchPoint *arg1 = 0 ;
45411   int arg2 ;
45412   std::vector< Dali::TouchPoint > *result = 0 ;
45413
45414   arg1 = (Dali::TouchPoint *)jarg1;
45415   if (!arg1) {
45416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45417     return 0;
45418   }
45419   arg2 = (int)jarg2;
45420   {
45421     try {
45422       try {
45423         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45424       }
45425       catch(std::out_of_range &_e) {
45426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45427         return 0;
45428       }
45429
45430     } catch (std::out_of_range& e) {
45431       {
45432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45433       };
45434     } catch (std::exception& e) {
45435       {
45436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (...) {
45439       {
45440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45441       };
45442     }
45443   }
45444   jresult = (void *)result;
45445   return jresult;
45446 }
45447
45448
45449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45450   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45451
45452   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45453   {
45454     try {
45455       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45456     } catch (std::out_of_range& e) {
45457       {
45458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45459       };
45460     } catch (std::exception& e) {
45461       {
45462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45463       };
45464     } catch (...) {
45465       {
45466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45467       };
45468     }
45469   }
45470 }
45471
45472
45473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45474   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45475   int arg2 ;
45476   int arg3 ;
45477
45478   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45479   arg2 = (int)jarg2;
45480   arg3 = (int)jarg3;
45481   {
45482     try {
45483       try {
45484         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45485       }
45486       catch(std::out_of_range &_e) {
45487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45488         return ;
45489       }
45490       catch(std::invalid_argument &_e) {
45491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45492         return ;
45493       }
45494
45495     } catch (std::out_of_range& e) {
45496       {
45497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45498       };
45499     } catch (std::exception& e) {
45500       {
45501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45502       };
45503     } catch (...) {
45504       {
45505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45506       };
45507     }
45508   }
45509 }
45510
45511
45512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45513   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45514   int arg2 ;
45515   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45516
45517   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45518   arg2 = (int)jarg2;
45519   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45520   if (!arg3) {
45521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45522     return ;
45523   }
45524   {
45525     try {
45526       try {
45527         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45528       }
45529       catch(std::out_of_range &_e) {
45530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45531         return ;
45532       }
45533
45534     } catch (std::out_of_range& e) {
45535       {
45536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45537       };
45538     } catch (std::exception& e) {
45539       {
45540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45541       };
45542     } catch (...) {
45543       {
45544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45545       };
45546     }
45547   }
45548 }
45549
45550
45551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45552   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45553
45554   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45555   {
45556     try {
45557       delete arg1;
45558     } catch (std::out_of_range& e) {
45559       {
45560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45561       };
45562     } catch (std::exception& e) {
45563       {
45564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45565       };
45566     } catch (...) {
45567       {
45568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45569       };
45570     }
45571   }
45572 }
45573
45574
45575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45576   void * jresult ;
45577   Dali::Rect< int > *result = 0 ;
45578
45579   {
45580     try {
45581       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45582     } catch (std::out_of_range& e) {
45583       {
45584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45585       };
45586     } catch (std::exception& e) {
45587       {
45588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (...) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45593       };
45594     }
45595   }
45596   jresult = (void *)result;
45597   return jresult;
45598 }
45599
45600
45601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45602   void * jresult ;
45603   int arg1 ;
45604   int arg2 ;
45605   int arg3 ;
45606   int arg4 ;
45607   Dali::Rect< int > *result = 0 ;
45608
45609   arg1 = (int)jarg1;
45610   arg2 = (int)jarg2;
45611   arg3 = (int)jarg3;
45612   arg4 = (int)jarg4;
45613   {
45614     try {
45615       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45616     } catch (std::out_of_range& e) {
45617       {
45618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45619       };
45620     } catch (std::exception& e) {
45621       {
45622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45623       };
45624     } catch (...) {
45625       {
45626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45627       };
45628     }
45629   }
45630   jresult = (void *)result;
45631   return jresult;
45632 }
45633
45634
45635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45636   void * jresult ;
45637   Dali::Rect< int > *arg1 = 0 ;
45638   Dali::Rect< int > *result = 0 ;
45639
45640   arg1 = (Dali::Rect< int > *)jarg1;
45641   if (!arg1) {
45642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45643     return 0;
45644   }
45645   {
45646     try {
45647       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45648     } catch (std::out_of_range& e) {
45649       {
45650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45651       };
45652     } catch (std::exception& e) {
45653       {
45654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45655       };
45656     } catch (...) {
45657       {
45658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45659       };
45660     }
45661   }
45662   jresult = (void *)result;
45663   return jresult;
45664 }
45665
45666
45667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45668   void * jresult ;
45669   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45670   Dali::Rect< int > *arg2 = 0 ;
45671   Dali::Rect< int > *result = 0 ;
45672
45673   arg1 = (Dali::Rect< int > *)jarg1;
45674   arg2 = (Dali::Rect< int > *)jarg2;
45675   if (!arg2) {
45676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45677     return 0;
45678   }
45679   {
45680     try {
45681       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45682     } catch (std::out_of_range& e) {
45683       {
45684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45685       };
45686     } catch (std::exception& e) {
45687       {
45688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45689       };
45690     } catch (...) {
45691       {
45692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45693       };
45694     }
45695   }
45696   jresult = (void *)result;
45697   return jresult;
45698 }
45699
45700
45701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45702   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45703   int arg2 ;
45704   int arg3 ;
45705   int arg4 ;
45706   int arg5 ;
45707
45708   arg1 = (Dali::Rect< int > *)jarg1;
45709   arg2 = (int)jarg2;
45710   arg3 = (int)jarg3;
45711   arg4 = (int)jarg4;
45712   arg5 = (int)jarg5;
45713   {
45714     try {
45715       (arg1)->Set(arg2,arg3,arg4,arg5);
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45723       };
45724     } catch (...) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45727       };
45728     }
45729   }
45730 }
45731
45732
45733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45734   unsigned int jresult ;
45735   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45736   bool result;
45737
45738   arg1 = (Dali::Rect< int > *)jarg1;
45739   {
45740     try {
45741       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45742     } catch (std::out_of_range& e) {
45743       {
45744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45745       };
45746     } catch (std::exception& e) {
45747       {
45748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45749       };
45750     } catch (...) {
45751       {
45752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45753       };
45754     }
45755   }
45756   jresult = result;
45757   return jresult;
45758 }
45759
45760
45761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45762   int jresult ;
45763   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45764   int result;
45765
45766   arg1 = (Dali::Rect< int > *)jarg1;
45767   {
45768     try {
45769       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45770     } catch (std::out_of_range& e) {
45771       {
45772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45773       };
45774     } catch (std::exception& e) {
45775       {
45776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45777       };
45778     } catch (...) {
45779       {
45780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45781       };
45782     }
45783   }
45784   jresult = result;
45785   return jresult;
45786 }
45787
45788
45789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45790   int jresult ;
45791   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45792   int result;
45793
45794   arg1 = (Dali::Rect< int > *)jarg1;
45795   {
45796     try {
45797       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45798     } catch (std::out_of_range& e) {
45799       {
45800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45801       };
45802     } catch (std::exception& e) {
45803       {
45804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (...) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45809       };
45810     }
45811   }
45812   jresult = result;
45813   return jresult;
45814 }
45815
45816
45817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45818   int jresult ;
45819   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45820   int result;
45821
45822   arg1 = (Dali::Rect< int > *)jarg1;
45823   {
45824     try {
45825       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45826     } catch (std::out_of_range& e) {
45827       {
45828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45829       };
45830     } catch (std::exception& e) {
45831       {
45832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45833       };
45834     } catch (...) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45837       };
45838     }
45839   }
45840   jresult = result;
45841   return jresult;
45842 }
45843
45844
45845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45846   int jresult ;
45847   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45848   int result;
45849
45850   arg1 = (Dali::Rect< int > *)jarg1;
45851   {
45852     try {
45853       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45854     } catch (std::out_of_range& e) {
45855       {
45856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45857       };
45858     } catch (std::exception& e) {
45859       {
45860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45861       };
45862     } catch (...) {
45863       {
45864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45865       };
45866     }
45867   }
45868   jresult = result;
45869   return jresult;
45870 }
45871
45872
45873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45874   int jresult ;
45875   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45876   int result;
45877
45878   arg1 = (Dali::Rect< int > *)jarg1;
45879   {
45880     try {
45881       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45882     } catch (std::out_of_range& e) {
45883       {
45884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45885       };
45886     } catch (std::exception& e) {
45887       {
45888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (...) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45893       };
45894     }
45895   }
45896   jresult = result;
45897   return jresult;
45898 }
45899
45900
45901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45902   unsigned int jresult ;
45903   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45904   Dali::Rect< int > *arg2 = 0 ;
45905   bool result;
45906
45907   arg1 = (Dali::Rect< int > *)jarg1;
45908   arg2 = (Dali::Rect< int > *)jarg2;
45909   if (!arg2) {
45910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45911     return 0;
45912   }
45913   {
45914     try {
45915       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45916     } catch (std::out_of_range& e) {
45917       {
45918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45919       };
45920     } catch (std::exception& e) {
45921       {
45922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45923       };
45924     } catch (...) {
45925       {
45926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45927       };
45928     }
45929   }
45930   jresult = result;
45931   return jresult;
45932 }
45933
45934
45935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45936   unsigned int jresult ;
45937   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45938   Dali::Rect< int > *arg2 = 0 ;
45939   bool result;
45940
45941   arg1 = (Dali::Rect< int > *)jarg1;
45942   arg2 = (Dali::Rect< int > *)jarg2;
45943   if (!arg2) {
45944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45945     return 0;
45946   }
45947   {
45948     try {
45949       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45950     } catch (std::out_of_range& e) {
45951       {
45952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45953       };
45954     } catch (std::exception& e) {
45955       {
45956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45957       };
45958     } catch (...) {
45959       {
45960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45961       };
45962     }
45963   }
45964   jresult = result;
45965   return jresult;
45966 }
45967
45968
45969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45970   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45971   int arg2 ;
45972
45973   arg1 = (Dali::Rect< int > *)jarg1;
45974   arg2 = (int)jarg2;
45975   if (arg1) (arg1)->x = arg2;
45976 }
45977
45978
45979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45980   int jresult ;
45981   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45982   int result;
45983
45984   arg1 = (Dali::Rect< int > *)jarg1;
45985   result = (int) ((arg1)->x);
45986   jresult = result;
45987   return jresult;
45988 }
45989
45990
45991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45992   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45993   int arg2 ;
45994
45995   arg1 = (Dali::Rect< int > *)jarg1;
45996   arg2 = (int)jarg2;
45997   if (arg1) (arg1)->left = arg2;
45998 }
45999
46000
46001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
46002   int jresult ;
46003   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46004   int result;
46005
46006   arg1 = (Dali::Rect< int > *)jarg1;
46007   result = (int) ((arg1)->left);
46008   jresult = result;
46009   return jresult;
46010 }
46011
46012
46013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
46014   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46015   int arg2 ;
46016
46017   arg1 = (Dali::Rect< int > *)jarg1;
46018   arg2 = (int)jarg2;
46019   if (arg1) (arg1)->y = arg2;
46020 }
46021
46022
46023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46024   int jresult ;
46025   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46026   int result;
46027
46028   arg1 = (Dali::Rect< int > *)jarg1;
46029   result = (int) ((arg1)->y);
46030   jresult = result;
46031   return jresult;
46032 }
46033
46034
46035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46036   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46037   int arg2 ;
46038
46039   arg1 = (Dali::Rect< int > *)jarg1;
46040   arg2 = (int)jarg2;
46041   if (arg1) (arg1)->right = arg2;
46042 }
46043
46044
46045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46046   int jresult ;
46047   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46048   int result;
46049
46050   arg1 = (Dali::Rect< int > *)jarg1;
46051   result = (int) ((arg1)->right);
46052   jresult = result;
46053   return jresult;
46054 }
46055
46056
46057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46058   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46059   int arg2 ;
46060
46061   arg1 = (Dali::Rect< int > *)jarg1;
46062   arg2 = (int)jarg2;
46063   if (arg1) (arg1)->width = arg2;
46064 }
46065
46066
46067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46068   int jresult ;
46069   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46070   int result;
46071
46072   arg1 = (Dali::Rect< int > *)jarg1;
46073   result = (int) ((arg1)->width);
46074   jresult = result;
46075   return jresult;
46076 }
46077
46078
46079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46080   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46081   int arg2 ;
46082
46083   arg1 = (Dali::Rect< int > *)jarg1;
46084   arg2 = (int)jarg2;
46085   if (arg1) (arg1)->bottom = arg2;
46086 }
46087
46088
46089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46090   int jresult ;
46091   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46092   int result;
46093
46094   arg1 = (Dali::Rect< int > *)jarg1;
46095   result = (int) ((arg1)->bottom);
46096   jresult = result;
46097   return jresult;
46098 }
46099
46100
46101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46102   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46103   int arg2 ;
46104
46105   arg1 = (Dali::Rect< int > *)jarg1;
46106   arg2 = (int)jarg2;
46107   if (arg1) (arg1)->height = arg2;
46108 }
46109
46110
46111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46112   int jresult ;
46113   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46114   int result;
46115
46116   arg1 = (Dali::Rect< int > *)jarg1;
46117   result = (int) ((arg1)->height);
46118   jresult = result;
46119   return jresult;
46120 }
46121
46122
46123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46124   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46125   int arg2 ;
46126
46127   arg1 = (Dali::Rect< int > *)jarg1;
46128   arg2 = (int)jarg2;
46129   if (arg1) (arg1)->top = arg2;
46130 }
46131
46132
46133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46134   int jresult ;
46135   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46136   int result;
46137
46138   arg1 = (Dali::Rect< int > *)jarg1;
46139   result = (int) ((arg1)->top);
46140   jresult = result;
46141   return jresult;
46142 }
46143
46144
46145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46146   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46147
46148   arg1 = (Dali::Rect< int > *)jarg1;
46149   {
46150     try {
46151       delete arg1;
46152     } catch (std::out_of_range& e) {
46153       {
46154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46155       };
46156     } catch (std::exception& e) {
46157       {
46158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46159       };
46160     } catch (...) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46163       };
46164     }
46165   }
46166 }
46167
46168
46169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46170   void * jresult ;
46171   Dali::Rect< float > *result = 0 ;
46172
46173   {
46174     try {
46175       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46176     } catch (std::out_of_range& e) {
46177       {
46178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46179       };
46180     } catch (std::exception& e) {
46181       {
46182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46183       };
46184     } catch (...) {
46185       {
46186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46187       };
46188     }
46189   }
46190   jresult = (void *)result;
46191   return jresult;
46192 }
46193
46194
46195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46196   void * jresult ;
46197   float arg1 ;
46198   float arg2 ;
46199   float arg3 ;
46200   float arg4 ;
46201   Dali::Rect< float > *result = 0 ;
46202
46203   arg1 = (float)jarg1;
46204   arg2 = (float)jarg2;
46205   arg3 = (float)jarg3;
46206   arg4 = (float)jarg4;
46207   {
46208     try {
46209       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46210     } catch (std::out_of_range& e) {
46211       {
46212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46213       };
46214     } catch (std::exception& e) {
46215       {
46216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46217       };
46218     } catch (...) {
46219       {
46220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46221       };
46222     }
46223   }
46224   jresult = (void *)result;
46225   return jresult;
46226 }
46227
46228
46229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46230   void * jresult ;
46231   Dali::Rect< float > *arg1 = 0 ;
46232   Dali::Rect< float > *result = 0 ;
46233
46234   arg1 = (Dali::Rect< float > *)jarg1;
46235   if (!arg1) {
46236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46237     return 0;
46238   }
46239   {
46240     try {
46241       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46242     } catch (std::out_of_range& e) {
46243       {
46244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46245       };
46246     } catch (std::exception& e) {
46247       {
46248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46253       };
46254     }
46255   }
46256   jresult = (void *)result;
46257   return jresult;
46258 }
46259
46260
46261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46262   void * jresult ;
46263   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46264   Dali::Rect< float > *arg2 = 0 ;
46265   Dali::Rect< float > *result = 0 ;
46266
46267   arg1 = (Dali::Rect< float > *)jarg1;
46268   arg2 = (Dali::Rect< float > *)jarg2;
46269   if (!arg2) {
46270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46271     return 0;
46272   }
46273   {
46274     try {
46275       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46276     } catch (std::out_of_range& e) {
46277       {
46278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46279       };
46280     } catch (std::exception& e) {
46281       {
46282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46283       };
46284     } catch (...) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46287       };
46288     }
46289   }
46290   jresult = (void *)result;
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46296   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46297   float arg2 ;
46298   float arg3 ;
46299   float arg4 ;
46300   float arg5 ;
46301
46302   arg1 = (Dali::Rect< float > *)jarg1;
46303   arg2 = (float)jarg2;
46304   arg3 = (float)jarg3;
46305   arg4 = (float)jarg4;
46306   arg5 = (float)jarg5;
46307   {
46308     try {
46309       (arg1)->Set(arg2,arg3,arg4,arg5);
46310     } catch (std::out_of_range& e) {
46311       {
46312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46313       };
46314     } catch (std::exception& e) {
46315       {
46316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46317       };
46318     } catch (...) {
46319       {
46320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46321       };
46322     }
46323   }
46324 }
46325
46326
46327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46328   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46329   float arg2 ;
46330
46331   arg1 = (Dali::Rect< float > *)jarg1;
46332   arg2 = (float)jarg2;
46333   if (arg1) (arg1)->x = arg2;
46334 }
46335
46336
46337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46338   float jresult ;
46339   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46340   float result;
46341
46342   arg1 = (Dali::Rect< float > *)jarg1;
46343   result = (float) ((arg1)->x);
46344   jresult = result;
46345   return jresult;
46346 }
46347
46348
46349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46351   float arg2 ;
46352
46353   arg1 = (Dali::Rect< float > *)jarg1;
46354   arg2 = (float)jarg2;
46355   if (arg1) (arg1)->left = arg2;
46356 }
46357
46358
46359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46360   float jresult ;
46361   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46362   float result;
46363
46364   arg1 = (Dali::Rect< float > *)jarg1;
46365   result = (float) ((arg1)->left);
46366   jresult = result;
46367   return jresult;
46368 }
46369
46370
46371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46372   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46373   float arg2 ;
46374
46375   arg1 = (Dali::Rect< float > *)jarg1;
46376   arg2 = (float)jarg2;
46377   if (arg1) (arg1)->y = arg2;
46378 }
46379
46380
46381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46382   float jresult ;
46383   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46384   float result;
46385
46386   arg1 = (Dali::Rect< float > *)jarg1;
46387   result = (float) ((arg1)->y);
46388   jresult = result;
46389   return jresult;
46390 }
46391
46392
46393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46394   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46395   float arg2 ;
46396
46397   arg1 = (Dali::Rect< float > *)jarg1;
46398   arg2 = (float)jarg2;
46399   if (arg1) (arg1)->right = arg2;
46400 }
46401
46402
46403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46404   float jresult ;
46405   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46406   float result;
46407
46408   arg1 = (Dali::Rect< float > *)jarg1;
46409   result = (float) ((arg1)->right);
46410   jresult = result;
46411   return jresult;
46412 }
46413
46414
46415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46416   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46417   float arg2 ;
46418
46419   arg1 = (Dali::Rect< float > *)jarg1;
46420   arg2 = (float)jarg2;
46421   if (arg1) (arg1)->width = arg2;
46422 }
46423
46424
46425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46426   float jresult ;
46427   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46428   float result;
46429
46430   arg1 = (Dali::Rect< float > *)jarg1;
46431   result = (float) ((arg1)->width);
46432   jresult = result;
46433   return jresult;
46434 }
46435
46436
46437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46438   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46439   float arg2 ;
46440
46441   arg1 = (Dali::Rect< float > *)jarg1;
46442   arg2 = (float)jarg2;
46443   if (arg1) (arg1)->bottom = arg2;
46444 }
46445
46446
46447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46448   float jresult ;
46449   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46450   float result;
46451
46452   arg1 = (Dali::Rect< float > *)jarg1;
46453   result = (float) ((arg1)->bottom);
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46460   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46461   float arg2 ;
46462
46463   arg1 = (Dali::Rect< float > *)jarg1;
46464   arg2 = (float)jarg2;
46465   if (arg1) (arg1)->height = arg2;
46466 }
46467
46468
46469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46470   float jresult ;
46471   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46472   float result;
46473
46474   arg1 = (Dali::Rect< float > *)jarg1;
46475   result = (float) ((arg1)->height);
46476   jresult = result;
46477   return jresult;
46478 }
46479
46480
46481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46482   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46483   float arg2 ;
46484
46485   arg1 = (Dali::Rect< float > *)jarg1;
46486   arg2 = (float)jarg2;
46487   if (arg1) (arg1)->top = arg2;
46488 }
46489
46490
46491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46492   float jresult ;
46493   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46494   float result;
46495
46496   arg1 = (Dali::Rect< float > *)jarg1;
46497   result = (float) ((arg1)->top);
46498   jresult = result;
46499   return jresult;
46500 }
46501
46502
46503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46504   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46505
46506   arg1 = (Dali::Rect< float > *)jarg1;
46507   {
46508     try {
46509       delete arg1;
46510     } catch (std::out_of_range& e) {
46511       {
46512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46513       };
46514     } catch (std::exception& e) {
46515       {
46516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46517       };
46518     } catch (...) {
46519       {
46520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46521       };
46522     }
46523   }
46524 }
46525
46526
46527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46528   int jresult ;
46529   int result;
46530
46531   result = (int)Dali::Vector< int >::BaseType;
46532   jresult = (int)result;
46533   return jresult;
46534 }
46535
46536
46537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46538   void * jresult ;
46539   Dali::Vector< int > *result = 0 ;
46540
46541   {
46542     try {
46543       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46544     } catch (std::out_of_range& e) {
46545       {
46546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (std::exception& e) {
46549       {
46550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46551       };
46552     } catch (...) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46555       };
46556     }
46557   }
46558   jresult = (void *)result;
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46564   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46565
46566   arg1 = (Dali::Vector< int > *)jarg1;
46567   {
46568     try {
46569       delete arg1;
46570     } catch (std::out_of_range& e) {
46571       {
46572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46573       };
46574     } catch (std::exception& e) {
46575       {
46576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (...) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46581       };
46582     }
46583   }
46584 }
46585
46586
46587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46588   void * jresult ;
46589   Dali::Vector< int > *arg1 = 0 ;
46590   Dali::Vector< int > *result = 0 ;
46591
46592   arg1 = (Dali::Vector< int > *)jarg1;
46593   if (!arg1) {
46594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46595     return 0;
46596   }
46597   {
46598     try {
46599       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46600     } catch (std::out_of_range& e) {
46601       {
46602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46603       };
46604     } catch (std::exception& e) {
46605       {
46606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46607       };
46608     } catch (...) {
46609       {
46610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46611       };
46612     }
46613   }
46614   jresult = (void *)result;
46615   return jresult;
46616 }
46617
46618
46619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46620   void * jresult ;
46621   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46622   Dali::Vector< int > *arg2 = 0 ;
46623   Dali::Vector< int > *result = 0 ;
46624
46625   arg1 = (Dali::Vector< int > *)jarg1;
46626   arg2 = (Dali::Vector< int > *)jarg2;
46627   if (!arg2) {
46628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46629     return 0;
46630   }
46631   {
46632     try {
46633       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46634     } catch (std::out_of_range& e) {
46635       {
46636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46637       };
46638     } catch (std::exception& e) {
46639       {
46640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46641       };
46642     } catch (...) {
46643       {
46644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46645       };
46646     }
46647   }
46648   jresult = (void *)result;
46649   return jresult;
46650 }
46651
46652
46653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46654   void * jresult ;
46655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46656   Dali::Vector< int >::Iterator result;
46657
46658   arg1 = (Dali::Vector< int > *)jarg1;
46659   {
46660     try {
46661       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46662     } catch (std::out_of_range& e) {
46663       {
46664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46665       };
46666     } catch (std::exception& e) {
46667       {
46668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46669       };
46670     } catch (...) {
46671       {
46672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46673       };
46674     }
46675   }
46676   jresult = (void *)result;
46677   return jresult;
46678 }
46679
46680
46681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46682   void * jresult ;
46683   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46684   Dali::Vector< int >::Iterator result;
46685
46686   arg1 = (Dali::Vector< int > *)jarg1;
46687   {
46688     try {
46689       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46690     } catch (std::out_of_range& e) {
46691       {
46692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46693       };
46694     } catch (std::exception& e) {
46695       {
46696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46697       };
46698     } catch (...) {
46699       {
46700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46701       };
46702     }
46703   }
46704   jresult = (void *)result;
46705   return jresult;
46706 }
46707
46708
46709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46710   void * jresult ;
46711   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46712   Dali::Vector< int >::SizeType arg2 ;
46713   Dali::Vector< int >::ItemType *result = 0 ;
46714
46715   arg1 = (Dali::Vector< int > *)jarg1;
46716   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46717   {
46718     try {
46719       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46720     } catch (std::out_of_range& e) {
46721       {
46722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46723       };
46724     } catch (std::exception& e) {
46725       {
46726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46727       };
46728     } catch (...) {
46729       {
46730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46731       };
46732     }
46733   }
46734   jresult = (void *)result;
46735   return jresult;
46736 }
46737
46738
46739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46740   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46741   Dali::Vector< int >::ItemType *arg2 = 0 ;
46742   Dali::Vector< int >::ItemType temp2 ;
46743
46744   arg1 = (Dali::Vector< int > *)jarg1;
46745   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46746   arg2 = &temp2;
46747   {
46748     try {
46749       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46750     } catch (std::out_of_range& e) {
46751       {
46752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46753       };
46754     } catch (std::exception& e) {
46755       {
46756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46757       };
46758     } catch (...) {
46759       {
46760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46761       };
46762     }
46763   }
46764 }
46765
46766
46767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46768   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46769   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46770   Dali::Vector< int >::ItemType *arg3 = 0 ;
46771   Dali::Vector< int >::ItemType temp3 ;
46772
46773   arg1 = (Dali::Vector< int > *)jarg1;
46774   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46775   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46776   arg3 = &temp3;
46777   {
46778     try {
46779       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46780     } catch (std::out_of_range& e) {
46781       {
46782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46783       };
46784     } catch (std::exception& e) {
46785       {
46786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46787       };
46788     } catch (...) {
46789       {
46790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46791       };
46792     }
46793   }
46794 }
46795
46796
46797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46798   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46799   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46800   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46801   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46802
46803   arg1 = (Dali::Vector< int > *)jarg1;
46804   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46805   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46806   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46807   {
46808     try {
46809       (arg1)->Insert(arg2,arg3,arg4);
46810     } catch (std::out_of_range& e) {
46811       {
46812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46813       };
46814     } catch (std::exception& e) {
46815       {
46816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46817       };
46818     } catch (...) {
46819       {
46820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46821       };
46822     }
46823   }
46824 }
46825
46826
46827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46828   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46829   Dali::Vector< int >::SizeType arg2 ;
46830
46831   arg1 = (Dali::Vector< int > *)jarg1;
46832   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46833   {
46834     try {
46835       (arg1)->Reserve(arg2);
46836     } catch (std::out_of_range& e) {
46837       {
46838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46839       };
46840     } catch (std::exception& e) {
46841       {
46842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46843       };
46844     } catch (...) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46847       };
46848     }
46849   }
46850 }
46851
46852
46853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46854   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46855   Dali::Vector< int >::SizeType arg2 ;
46856
46857   arg1 = (Dali::Vector< int > *)jarg1;
46858   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46859   {
46860     try {
46861       (arg1)->Resize(arg2);
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46869       };
46870     } catch (...) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46873       };
46874     }
46875   }
46876 }
46877
46878
46879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46880   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46881   Dali::Vector< int >::SizeType arg2 ;
46882   Dali::Vector< int >::ItemType *arg3 = 0 ;
46883   Dali::Vector< int >::ItemType temp3 ;
46884
46885   arg1 = (Dali::Vector< int > *)jarg1;
46886   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46887   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46888   arg3 = &temp3;
46889   {
46890     try {
46891       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46892     } catch (std::out_of_range& e) {
46893       {
46894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46895       };
46896     } catch (std::exception& e) {
46897       {
46898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46899       };
46900     } catch (...) {
46901       {
46902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46903       };
46904     }
46905   }
46906 }
46907
46908
46909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46910   void * jresult ;
46911   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46912   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46913   Dali::Vector< int >::Iterator result;
46914
46915   arg1 = (Dali::Vector< int > *)jarg1;
46916   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46917   {
46918     try {
46919       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46920     } catch (std::out_of_range& e) {
46921       {
46922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46923       };
46924     } catch (std::exception& e) {
46925       {
46926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46927       };
46928     } catch (...) {
46929       {
46930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46931       };
46932     }
46933   }
46934   jresult = (void *)result;
46935   return jresult;
46936 }
46937
46938
46939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46940   void * jresult ;
46941   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46942   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46943   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46944   Dali::Vector< int >::Iterator result;
46945
46946   arg1 = (Dali::Vector< int > *)jarg1;
46947   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46948   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46949   {
46950     try {
46951       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46952     } catch (std::out_of_range& e) {
46953       {
46954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46955       };
46956     } catch (std::exception& e) {
46957       {
46958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46959       };
46960     } catch (...) {
46961       {
46962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46963       };
46964     }
46965   }
46966   jresult = (void *)result;
46967   return jresult;
46968 }
46969
46970
46971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46972   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46973   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46974
46975   arg1 = (Dali::Vector< int > *)jarg1;
46976   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46977   {
46978     try {
46979       (arg1)->Remove(arg2);
46980     } catch (std::out_of_range& e) {
46981       {
46982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46983       };
46984     } catch (std::exception& e) {
46985       {
46986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46987       };
46988     } catch (...) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46991       };
46992     }
46993   }
46994 }
46995
46996
46997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46998   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46999   Dali::Vector< int > *arg2 = 0 ;
47000
47001   arg1 = (Dali::Vector< int > *)jarg1;
47002   arg2 = (Dali::Vector< int > *)jarg2;
47003   if (!arg2) {
47004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
47005     return ;
47006   }
47007   {
47008     try {
47009       (arg1)->Swap(*arg2);
47010     } catch (std::out_of_range& e) {
47011       {
47012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47013       };
47014     } catch (std::exception& e) {
47015       {
47016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47017       };
47018     } catch (...) {
47019       {
47020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47021       };
47022     }
47023   }
47024 }
47025
47026
47027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47028   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47029
47030   arg1 = (Dali::Vector< int > *)jarg1;
47031   {
47032     try {
47033       (arg1)->Clear();
47034     } catch (std::out_of_range& e) {
47035       {
47036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47037       };
47038     } catch (std::exception& e) {
47039       {
47040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47041       };
47042     } catch (...) {
47043       {
47044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47045       };
47046     }
47047   }
47048 }
47049
47050
47051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47052   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47053
47054   arg1 = (Dali::Vector< int > *)jarg1;
47055   {
47056     try {
47057       (arg1)->Release();
47058     } catch (std::out_of_range& e) {
47059       {
47060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47061       };
47062     } catch (std::exception& e) {
47063       {
47064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47065       };
47066     } catch (...) {
47067       {
47068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47069       };
47070     }
47071   }
47072 }
47073
47074
47075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47076   int jresult ;
47077   int result;
47078
47079   result = (int)Dali::Vector< float >::BaseType;
47080   jresult = (int)result;
47081   return jresult;
47082 }
47083
47084
47085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47086   void * jresult ;
47087   Dali::Vector< float > *result = 0 ;
47088
47089   {
47090     try {
47091       result = (Dali::Vector< float > *)new Dali::Vector< float >();
47092     } catch (std::out_of_range& e) {
47093       {
47094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47095       };
47096     } catch (std::exception& e) {
47097       {
47098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47099       };
47100     } catch (...) {
47101       {
47102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47103       };
47104     }
47105   }
47106   jresult = (void *)result;
47107   return jresult;
47108 }
47109
47110
47111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
47112   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47113
47114   arg1 = (Dali::Vector< float > *)jarg1;
47115   {
47116     try {
47117       delete arg1;
47118     } catch (std::out_of_range& e) {
47119       {
47120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47121       };
47122     } catch (std::exception& e) {
47123       {
47124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47125       };
47126     } catch (...) {
47127       {
47128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47129       };
47130     }
47131   }
47132 }
47133
47134
47135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47136   void * jresult ;
47137   Dali::Vector< float > *arg1 = 0 ;
47138   Dali::Vector< float > *result = 0 ;
47139
47140   arg1 = (Dali::Vector< float > *)jarg1;
47141   if (!arg1) {
47142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47143     return 0;
47144   }
47145   {
47146     try {
47147       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47148     } catch (std::out_of_range& e) {
47149       {
47150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47151       };
47152     } catch (std::exception& e) {
47153       {
47154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47155       };
47156     } catch (...) {
47157       {
47158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47159       };
47160     }
47161   }
47162   jresult = (void *)result;
47163   return jresult;
47164 }
47165
47166
47167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47168   void * jresult ;
47169   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47170   Dali::Vector< float > *arg2 = 0 ;
47171   Dali::Vector< float > *result = 0 ;
47172
47173   arg1 = (Dali::Vector< float > *)jarg1;
47174   arg2 = (Dali::Vector< float > *)jarg2;
47175   if (!arg2) {
47176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47177     return 0;
47178   }
47179   {
47180     try {
47181       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47182     } catch (std::out_of_range& e) {
47183       {
47184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (std::exception& e) {
47187       {
47188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196   jresult = (void *)result;
47197   return jresult;
47198 }
47199
47200
47201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47202   void * jresult ;
47203   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47204   Dali::Vector< float >::Iterator result;
47205
47206   arg1 = (Dali::Vector< float > *)jarg1;
47207   {
47208     try {
47209       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47210     } catch (std::out_of_range& e) {
47211       {
47212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47213       };
47214     } catch (std::exception& e) {
47215       {
47216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47221       };
47222     }
47223   }
47224   jresult = (void *)result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47230   void * jresult ;
47231   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47232   Dali::Vector< float >::Iterator result;
47233
47234   arg1 = (Dali::Vector< float > *)jarg1;
47235   {
47236     try {
47237       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47238     } catch (std::out_of_range& e) {
47239       {
47240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47241       };
47242     } catch (std::exception& e) {
47243       {
47244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (...) {
47247       {
47248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47249       };
47250     }
47251   }
47252   jresult = (void *)result;
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47258   void * jresult ;
47259   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47260   Dali::Vector< float >::SizeType arg2 ;
47261   Dali::Vector< float >::ItemType *result = 0 ;
47262
47263   arg1 = (Dali::Vector< float > *)jarg1;
47264   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47265   {
47266     try {
47267       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47268     } catch (std::out_of_range& e) {
47269       {
47270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (std::exception& e) {
47273       {
47274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47275       };
47276     } catch (...) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47279       };
47280     }
47281   }
47282   jresult = (void *)result;
47283   return jresult;
47284 }
47285
47286
47287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47288   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47289   Dali::Vector< float >::ItemType *arg2 = 0 ;
47290   Dali::Vector< float >::ItemType temp2 ;
47291
47292   arg1 = (Dali::Vector< float > *)jarg1;
47293   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47294   arg2 = &temp2;
47295   {
47296     try {
47297       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47298     } catch (std::out_of_range& e) {
47299       {
47300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47301       };
47302     } catch (std::exception& e) {
47303       {
47304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47305       };
47306     } catch (...) {
47307       {
47308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47309       };
47310     }
47311   }
47312 }
47313
47314
47315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47316   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47317   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47318   Dali::Vector< float >::ItemType *arg3 = 0 ;
47319   Dali::Vector< float >::ItemType temp3 ;
47320
47321   arg1 = (Dali::Vector< float > *)jarg1;
47322   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47323   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47324   arg3 = &temp3;
47325   {
47326     try {
47327       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47328     } catch (std::out_of_range& e) {
47329       {
47330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47331       };
47332     } catch (std::exception& e) {
47333       {
47334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47339       };
47340     }
47341   }
47342 }
47343
47344
47345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47346   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47347   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47348   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47349   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47350
47351   arg1 = (Dali::Vector< float > *)jarg1;
47352   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47353   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47354   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47355   {
47356     try {
47357       (arg1)->Insert(arg2,arg3,arg4);
47358     } catch (std::out_of_range& e) {
47359       {
47360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47361       };
47362     } catch (std::exception& e) {
47363       {
47364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47365       };
47366     } catch (...) {
47367       {
47368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47369       };
47370     }
47371   }
47372 }
47373
47374
47375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47376   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47377   Dali::Vector< float >::SizeType arg2 ;
47378
47379   arg1 = (Dali::Vector< float > *)jarg1;
47380   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47381   {
47382     try {
47383       (arg1)->Reserve(arg2);
47384     } catch (std::out_of_range& e) {
47385       {
47386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (std::exception& e) {
47389       {
47390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (...) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47395       };
47396     }
47397   }
47398 }
47399
47400
47401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47402   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47403   Dali::Vector< float >::SizeType arg2 ;
47404
47405   arg1 = (Dali::Vector< float > *)jarg1;
47406   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47407   {
47408     try {
47409       (arg1)->Resize(arg2);
47410     } catch (std::out_of_range& e) {
47411       {
47412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47413       };
47414     } catch (std::exception& e) {
47415       {
47416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47417       };
47418     } catch (...) {
47419       {
47420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47421       };
47422     }
47423   }
47424 }
47425
47426
47427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47428   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47429   Dali::Vector< float >::SizeType arg2 ;
47430   Dali::Vector< float >::ItemType *arg3 = 0 ;
47431   Dali::Vector< float >::ItemType temp3 ;
47432
47433   arg1 = (Dali::Vector< float > *)jarg1;
47434   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47435   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47436   arg3 = &temp3;
47437   {
47438     try {
47439       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47440     } catch (std::out_of_range& e) {
47441       {
47442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47443       };
47444     } catch (std::exception& e) {
47445       {
47446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47447       };
47448     } catch (...) {
47449       {
47450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47451       };
47452     }
47453   }
47454 }
47455
47456
47457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47458   void * jresult ;
47459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47460   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47461   Dali::Vector< float >::Iterator result;
47462
47463   arg1 = (Dali::Vector< float > *)jarg1;
47464   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47465   {
47466     try {
47467       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47468     } catch (std::out_of_range& e) {
47469       {
47470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47471       };
47472     } catch (std::exception& e) {
47473       {
47474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47475       };
47476     } catch (...) {
47477       {
47478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47479       };
47480     }
47481   }
47482   jresult = (void *)result;
47483   return jresult;
47484 }
47485
47486
47487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47488   void * jresult ;
47489   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47490   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47491   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47492   Dali::Vector< float >::Iterator result;
47493
47494   arg1 = (Dali::Vector< float > *)jarg1;
47495   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47496   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47497   {
47498     try {
47499       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47500     } catch (std::out_of_range& e) {
47501       {
47502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47503       };
47504     } catch (std::exception& e) {
47505       {
47506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47507       };
47508     } catch (...) {
47509       {
47510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47511       };
47512     }
47513   }
47514   jresult = (void *)result;
47515   return jresult;
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47520   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47521   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47522
47523   arg1 = (Dali::Vector< float > *)jarg1;
47524   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47525   {
47526     try {
47527       (arg1)->Remove(arg2);
47528     } catch (std::out_of_range& e) {
47529       {
47530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47531       };
47532     } catch (std::exception& e) {
47533       {
47534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47535       };
47536     } catch (...) {
47537       {
47538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47539       };
47540     }
47541   }
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47546   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47547   Dali::Vector< float > *arg2 = 0 ;
47548
47549   arg1 = (Dali::Vector< float > *)jarg1;
47550   arg2 = (Dali::Vector< float > *)jarg2;
47551   if (!arg2) {
47552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47553     return ;
47554   }
47555   {
47556     try {
47557       (arg1)->Swap(*arg2);
47558     } catch (std::out_of_range& e) {
47559       {
47560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47561       };
47562     } catch (std::exception& e) {
47563       {
47564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47565       };
47566     } catch (...) {
47567       {
47568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47569       };
47570     }
47571   }
47572 }
47573
47574
47575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47576   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47577
47578   arg1 = (Dali::Vector< float > *)jarg1;
47579   {
47580     try {
47581       (arg1)->Clear();
47582     } catch (std::out_of_range& e) {
47583       {
47584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47585       };
47586     } catch (std::exception& e) {
47587       {
47588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47593       };
47594     }
47595   }
47596 }
47597
47598
47599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47600   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47601
47602   arg1 = (Dali::Vector< float > *)jarg1;
47603   {
47604     try {
47605       (arg1)->Release();
47606     } catch (std::out_of_range& e) {
47607       {
47608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47609       };
47610     } catch (std::exception& e) {
47611       {
47612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47613       };
47614     } catch (...) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47617       };
47618     }
47619   }
47620 }
47621
47622
47623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47624   int jresult ;
47625   int result;
47626
47627   result = (int)Dali::Vector< unsigned char >::BaseType;
47628   jresult = (int)result;
47629   return jresult;
47630 }
47631
47632
47633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47634   void * jresult ;
47635   Dali::Vector< unsigned char > *result = 0 ;
47636
47637   {
47638     try {
47639       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47640     } catch (std::out_of_range& e) {
47641       {
47642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47643       };
47644     } catch (std::exception& e) {
47645       {
47646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47647       };
47648     } catch (...) {
47649       {
47650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47651       };
47652     }
47653   }
47654   jresult = (void *)result;
47655   return jresult;
47656 }
47657
47658
47659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47660   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47661
47662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47663   {
47664     try {
47665       delete arg1;
47666     } catch (std::out_of_range& e) {
47667       {
47668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47669       };
47670     } catch (std::exception& e) {
47671       {
47672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47673       };
47674     } catch (...) {
47675       {
47676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47677       };
47678     }
47679   }
47680 }
47681
47682
47683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47684   void * jresult ;
47685   Dali::Vector< unsigned char > *arg1 = 0 ;
47686   Dali::Vector< unsigned char > *result = 0 ;
47687
47688   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47689   if (!arg1) {
47690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47691     return 0;
47692   }
47693   {
47694     try {
47695       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47696     } catch (std::out_of_range& e) {
47697       {
47698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47699       };
47700     } catch (std::exception& e) {
47701       {
47702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47703       };
47704     } catch (...) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47707       };
47708     }
47709   }
47710   jresult = (void *)result;
47711   return jresult;
47712 }
47713
47714
47715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47716   void * jresult ;
47717   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47718   Dali::Vector< unsigned char > *arg2 = 0 ;
47719   Dali::Vector< unsigned char > *result = 0 ;
47720
47721   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47722   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47723   if (!arg2) {
47724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47725     return 0;
47726   }
47727   {
47728     try {
47729       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47730     } catch (std::out_of_range& e) {
47731       {
47732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47733       };
47734     } catch (std::exception& e) {
47735       {
47736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (...) {
47739       {
47740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47741       };
47742     }
47743   }
47744   jresult = (void *)result;
47745   return jresult;
47746 }
47747
47748
47749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47750   void * jresult ;
47751   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47752   Dali::Vector< unsigned char >::Iterator result;
47753
47754   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47755   {
47756     try {
47757       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47758     } catch (std::out_of_range& e) {
47759       {
47760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47761       };
47762     } catch (std::exception& e) {
47763       {
47764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47765       };
47766     } catch (...) {
47767       {
47768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47769       };
47770     }
47771   }
47772   jresult = (void *)result;
47773   return jresult;
47774 }
47775
47776
47777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47778   void * jresult ;
47779   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47780   Dali::Vector< unsigned char >::Iterator result;
47781
47782   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47783   {
47784     try {
47785       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47786     } catch (std::out_of_range& e) {
47787       {
47788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47789       };
47790     } catch (std::exception& e) {
47791       {
47792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47793       };
47794     } catch (...) {
47795       {
47796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47797       };
47798     }
47799   }
47800   jresult = (void *)result;
47801   return jresult;
47802 }
47803
47804
47805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47806   void * jresult ;
47807   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47808   Dali::Vector< unsigned char >::SizeType arg2 ;
47809   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47810
47811   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47812   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47813   {
47814     try {
47815       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47816     } catch (std::out_of_range& e) {
47817       {
47818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47819       };
47820     } catch (std::exception& e) {
47821       {
47822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (...) {
47825       {
47826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47827       };
47828     }
47829   }
47830   jresult = (void *)result;
47831   return jresult;
47832 }
47833
47834
47835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47836   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47837   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47838   Dali::Vector< unsigned char >::ItemType temp2 ;
47839
47840   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47841   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47842   arg2 = &temp2;
47843   {
47844     try {
47845       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47846     } catch (std::out_of_range& e) {
47847       {
47848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47849       };
47850     } catch (std::exception& e) {
47851       {
47852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47853       };
47854     } catch (...) {
47855       {
47856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47857       };
47858     }
47859   }
47860 }
47861
47862
47863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47864   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47865   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47866   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47867   Dali::Vector< unsigned char >::ItemType temp3 ;
47868
47869   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47870   arg2 = jarg2;
47871   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47872   arg3 = &temp3;
47873   {
47874     try {
47875       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47876     } catch (std::out_of_range& e) {
47877       {
47878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47879       };
47880     } catch (std::exception& e) {
47881       {
47882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47887       };
47888     }
47889   }
47890
47891
47892 }
47893
47894
47895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47896   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47897   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47898   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47899   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47900
47901   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47902   arg2 = jarg2;
47903   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47904   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47905   {
47906     try {
47907       (arg1)->Insert(arg2,arg3,arg4);
47908     } catch (std::out_of_range& e) {
47909       {
47910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47911       };
47912     } catch (std::exception& e) {
47913       {
47914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47915       };
47916     } catch (...) {
47917       {
47918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47919       };
47920     }
47921   }
47922
47923
47924 }
47925
47926
47927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47929   Dali::Vector< unsigned char >::SizeType arg2 ;
47930
47931   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47932   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47933   {
47934     try {
47935       (arg1)->Reserve(arg2);
47936     } catch (std::out_of_range& e) {
47937       {
47938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47939       };
47940     } catch (std::exception& e) {
47941       {
47942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47943       };
47944     } catch (...) {
47945       {
47946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47947       };
47948     }
47949   }
47950 }
47951
47952
47953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47954   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47955   Dali::Vector< unsigned char >::SizeType arg2 ;
47956
47957   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47958   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47959   {
47960     try {
47961       (arg1)->Resize(arg2);
47962     } catch (std::out_of_range& e) {
47963       {
47964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47965       };
47966     } catch (std::exception& e) {
47967       {
47968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47969       };
47970     } catch (...) {
47971       {
47972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47973       };
47974     }
47975   }
47976 }
47977
47978
47979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47980   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47981   Dali::Vector< unsigned char >::SizeType arg2 ;
47982   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47983   Dali::Vector< unsigned char >::ItemType temp3 ;
47984
47985   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47986   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47987   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47988   arg3 = &temp3;
47989   {
47990     try {
47991       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47992     } catch (std::out_of_range& e) {
47993       {
47994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47995       };
47996     } catch (std::exception& e) {
47997       {
47998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47999       };
48000     } catch (...) {
48001       {
48002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48003       };
48004     }
48005   }
48006 }
48007
48008
48009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
48010   void * jresult ;
48011   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48012   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48013   Dali::Vector< unsigned char >::Iterator result;
48014
48015   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48016   arg2 = jarg2;
48017   {
48018     try {
48019       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48020     } catch (std::out_of_range& e) {
48021       {
48022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48023       };
48024     } catch (std::exception& e) {
48025       {
48026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48027       };
48028     } catch (...) {
48029       {
48030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48031       };
48032     }
48033   }
48034   jresult = (void *)result;
48035
48036
48037   return jresult;
48038 }
48039
48040
48041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48042   void * jresult ;
48043   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48044   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48045   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48046   Dali::Vector< unsigned char >::Iterator result;
48047
48048   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48049   arg2 = jarg2;
48050   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48051   {
48052     try {
48053       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48054     } catch (std::out_of_range& e) {
48055       {
48056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48057       };
48058     } catch (std::exception& e) {
48059       {
48060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48061       };
48062     } catch (...) {
48063       {
48064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48065       };
48066     }
48067   }
48068   jresult = (void *)result;
48069
48070
48071   return jresult;
48072 }
48073
48074
48075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48076   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48077   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48078
48079   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48080   arg2 = jarg2;
48081   {
48082     try {
48083       (arg1)->Remove(arg2);
48084     } catch (std::out_of_range& e) {
48085       {
48086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48087       };
48088     } catch (std::exception& e) {
48089       {
48090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48091       };
48092     } catch (...) {
48093       {
48094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48095       };
48096     }
48097   }
48098
48099
48100 }
48101
48102
48103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48104   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48105   Dali::Vector< unsigned char > *arg2 = 0 ;
48106
48107   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48108   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48109   if (!arg2) {
48110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48111     return ;
48112   }
48113   {
48114     try {
48115       (arg1)->Swap(*arg2);
48116     } catch (std::out_of_range& e) {
48117       {
48118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48119       };
48120     } catch (std::exception& e) {
48121       {
48122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (...) {
48125       {
48126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48127       };
48128     }
48129   }
48130 }
48131
48132
48133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48134   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48135
48136   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48137   {
48138     try {
48139       (arg1)->Clear();
48140     } catch (std::out_of_range& e) {
48141       {
48142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48143       };
48144     } catch (std::exception& e) {
48145       {
48146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48147       };
48148     } catch (...) {
48149       {
48150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48151       };
48152     }
48153   }
48154 }
48155
48156
48157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48158   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48159
48160   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48161   {
48162     try {
48163       (arg1)->Release();
48164     } catch (std::out_of_range& e) {
48165       {
48166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48167       };
48168     } catch (std::exception& e) {
48169       {
48170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48171       };
48172     } catch (...) {
48173       {
48174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48175       };
48176     }
48177   }
48178 }
48179
48180
48181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48182   int jresult ;
48183   int result;
48184
48185   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48186   jresult = (int)result;
48187   return jresult;
48188 }
48189
48190
48191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48192   void * jresult ;
48193   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48194
48195   {
48196     try {
48197       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48198     } catch (std::out_of_range& e) {
48199       {
48200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48201       };
48202     } catch (std::exception& e) {
48203       {
48204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48205       };
48206     } catch (...) {
48207       {
48208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48209       };
48210     }
48211   }
48212   jresult = (void *)result;
48213   return jresult;
48214 }
48215
48216
48217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48218   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48219
48220   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48221   {
48222     try {
48223       delete arg1;
48224     } catch (std::out_of_range& e) {
48225       {
48226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48227       };
48228     } catch (std::exception& e) {
48229       {
48230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48231       };
48232     } catch (...) {
48233       {
48234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48235       };
48236     }
48237   }
48238 }
48239
48240
48241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48242   void * jresult ;
48243   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48244   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48245
48246   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48247   if (!arg1) {
48248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48249     return 0;
48250   }
48251   {
48252     try {
48253       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48254     } catch (std::out_of_range& e) {
48255       {
48256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48257       };
48258     } catch (std::exception& e) {
48259       {
48260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48261       };
48262     } catch (...) {
48263       {
48264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48265       };
48266     }
48267   }
48268   jresult = (void *)result;
48269   return jresult;
48270 }
48271
48272
48273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48274   void * jresult ;
48275   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48276   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48277   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48278
48279   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48280   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48281   if (!arg2) {
48282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48283     return 0;
48284   }
48285   {
48286     try {
48287       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48288     } catch (std::out_of_range& e) {
48289       {
48290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (std::exception& e) {
48293       {
48294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (...) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48299       };
48300     }
48301   }
48302   jresult = (void *)result;
48303   return jresult;
48304 }
48305
48306
48307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48308   void * jresult ;
48309   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48310   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48311
48312   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48313   {
48314     try {
48315       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48316     } catch (std::out_of_range& e) {
48317       {
48318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48319       };
48320     } catch (std::exception& e) {
48321       {
48322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48323       };
48324     } catch (...) {
48325       {
48326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48327       };
48328     }
48329   }
48330   jresult = (void *)result;
48331   return jresult;
48332 }
48333
48334
48335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48336   void * jresult ;
48337   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48338   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48339
48340   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48341   {
48342     try {
48343       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48344     } catch (std::out_of_range& e) {
48345       {
48346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (std::exception& e) {
48349       {
48350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48351       };
48352     } catch (...) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48355       };
48356     }
48357   }
48358   jresult = (void *)result;
48359   return jresult;
48360 }
48361
48362
48363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48364   void * jresult ;
48365   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48366   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48367   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48368
48369   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48370   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48371   {
48372     try {
48373       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48374     } catch (std::out_of_range& e) {
48375       {
48376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (std::exception& e) {
48379       {
48380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48385       };
48386     }
48387   }
48388   jresult = (void *)result;
48389   return jresult;
48390 }
48391
48392
48393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48394   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48395   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48396
48397   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48398   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48399   if (!arg2) {
48400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48401     return ;
48402   }
48403   {
48404     try {
48405       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48406     } catch (std::out_of_range& e) {
48407       {
48408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48409       };
48410     } catch (std::exception& e) {
48411       {
48412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (...) {
48415       {
48416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48417       };
48418     }
48419   }
48420 }
48421
48422
48423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48424   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48425   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48426   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48427
48428   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48429   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48430   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48431   if (!arg3) {
48432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48433     return ;
48434   }
48435   {
48436     try {
48437       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48438     } catch (std::out_of_range& e) {
48439       {
48440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48441       };
48442     } catch (std::exception& e) {
48443       {
48444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (...) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48449       };
48450     }
48451   }
48452 }
48453
48454
48455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48456   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48457   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48458   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48459   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48460
48461   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48462   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48463   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48464   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48465   {
48466     try {
48467       (arg1)->Insert(arg2,arg3,arg4);
48468     } catch (std::out_of_range& e) {
48469       {
48470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48471       };
48472     } catch (std::exception& e) {
48473       {
48474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48475       };
48476     } catch (...) {
48477       {
48478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48479       };
48480     }
48481   }
48482 }
48483
48484
48485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48486   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48487   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48488
48489   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48490   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48491   {
48492     try {
48493       (arg1)->Reserve(arg2);
48494     } catch (std::out_of_range& e) {
48495       {
48496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48497       };
48498     } catch (std::exception& e) {
48499       {
48500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48501       };
48502     } catch (...) {
48503       {
48504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48505       };
48506     }
48507   }
48508 }
48509
48510
48511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48512   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48513   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48514
48515   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48516   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48517   {
48518     try {
48519       (arg1)->Resize(arg2);
48520     } catch (std::out_of_range& e) {
48521       {
48522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48523       };
48524     } catch (std::exception& e) {
48525       {
48526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48527       };
48528     } catch (...) {
48529       {
48530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48531       };
48532     }
48533   }
48534 }
48535
48536
48537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48538   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48539   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48540   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48541
48542   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48543   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48544   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48545   if (!arg3) {
48546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48547     return ;
48548   }
48549   {
48550     try {
48551       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48552     } catch (std::out_of_range& e) {
48553       {
48554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (std::exception& e) {
48557       {
48558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566 }
48567
48568
48569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48570   void * jresult ;
48571   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48572   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48573   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48574
48575   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48576   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48577   {
48578     try {
48579       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48580     } catch (std::out_of_range& e) {
48581       {
48582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48583       };
48584     } catch (std::exception& e) {
48585       {
48586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48591       };
48592     }
48593   }
48594   jresult = (void *)result;
48595   return jresult;
48596 }
48597
48598
48599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48600   void * jresult ;
48601   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48602   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48603   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48604   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48605
48606   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48607   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48608   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48609   {
48610     try {
48611       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48612     } catch (std::out_of_range& e) {
48613       {
48614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48615       };
48616     } catch (std::exception& e) {
48617       {
48618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48619       };
48620     } catch (...) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48623       };
48624     }
48625   }
48626   jresult = (void *)result;
48627   return jresult;
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48632   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48633   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48634
48635   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48636   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48637   {
48638     try {
48639       (arg1)->Remove(arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (...) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48651       };
48652     }
48653   }
48654 }
48655
48656
48657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48658   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48659   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48660
48661   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48662   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48663   if (!arg2) {
48664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48665     return ;
48666   }
48667   {
48668     try {
48669       (arg1)->Swap(*arg2);
48670     } catch (std::out_of_range& e) {
48671       {
48672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48673       };
48674     } catch (std::exception& e) {
48675       {
48676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (...) {
48679       {
48680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48681       };
48682     }
48683   }
48684 }
48685
48686
48687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48688   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48689
48690   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48691   {
48692     try {
48693       (arg1)->Clear();
48694     } catch (std::out_of_range& e) {
48695       {
48696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48697       };
48698     } catch (std::exception& e) {
48699       {
48700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (...) {
48703       {
48704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48705       };
48706     }
48707   }
48708 }
48709
48710
48711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48712   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48713
48714   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48715   {
48716     try {
48717       (arg1)->Release();
48718     } catch (std::out_of_range& e) {
48719       {
48720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48721       };
48722     } catch (std::exception& e) {
48723       {
48724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48725       };
48726     } catch (...) {
48727       {
48728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48729       };
48730     }
48731   }
48732 }
48733
48734
48735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48736   void * jresult ;
48737   Dali::Signal< void () > *result = 0 ;
48738
48739   {
48740     try {
48741       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48742     } catch (std::out_of_range& e) {
48743       {
48744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48745       };
48746     } catch (std::exception& e) {
48747       {
48748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48749       };
48750     } catch (...) {
48751       {
48752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48753       };
48754     }
48755   }
48756   jresult = (void *)result;
48757   return jresult;
48758 }
48759
48760
48761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48762   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48763
48764   arg1 = (Dali::Signal< void () > *)jarg1;
48765   {
48766     try {
48767       delete arg1;
48768     } catch (std::out_of_range& e) {
48769       {
48770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48771       };
48772     } catch (std::exception& e) {
48773       {
48774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (...) {
48777       {
48778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48779       };
48780     }
48781   }
48782 }
48783
48784
48785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48786   unsigned int jresult ;
48787   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48788   bool result;
48789
48790   arg1 = (Dali::Signal< void () > *)jarg1;
48791   {
48792     try {
48793       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48794     } catch (std::out_of_range& e) {
48795       {
48796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48797       };
48798     } catch (std::exception& e) {
48799       {
48800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48801       };
48802     } catch (...) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48805       };
48806     }
48807   }
48808   jresult = result;
48809   return jresult;
48810 }
48811
48812
48813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48814   unsigned long jresult ;
48815   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48816   std::size_t result;
48817
48818   arg1 = (Dali::Signal< void () > *)jarg1;
48819   {
48820     try {
48821       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48822     } catch (std::out_of_range& e) {
48823       {
48824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48825       };
48826     } catch (std::exception& e) {
48827       {
48828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48829       };
48830     } catch (...) {
48831       {
48832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48833       };
48834     }
48835   }
48836   jresult = (unsigned long)result;
48837   return jresult;
48838 }
48839
48840
48841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48842   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48843   void (*arg2)() = (void (*)()) 0 ;
48844
48845   arg1 = (Dali::Signal< void () > *)jarg1;
48846   arg2 = (void (*)())jarg2;
48847   {
48848     try {
48849       (arg1)->Connect(arg2);
48850     } catch (std::out_of_range& e) {
48851       {
48852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48853       };
48854     } catch (std::exception& e) {
48855       {
48856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48857       };
48858     } catch (...) {
48859       {
48860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48861       };
48862     }
48863   }
48864 }
48865
48866
48867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48868   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48869   void (*arg2)() = (void (*)()) 0 ;
48870
48871   arg1 = (Dali::Signal< void () > *)jarg1;
48872   arg2 = (void (*)())jarg2;
48873   {
48874     try {
48875       (arg1)->Disconnect(arg2);
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (...) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48887       };
48888     }
48889   }
48890 }
48891
48892
48893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48894   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48895   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48896   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48897
48898   arg1 = (Dali::Signal< void () > *)jarg1;
48899   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48900   arg3 = (Dali::FunctorDelegate *)jarg3;
48901   {
48902     try {
48903       (arg1)->Connect(arg2,arg3);
48904     } catch (std::out_of_range& e) {
48905       {
48906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48907       };
48908     } catch (std::exception& e) {
48909       {
48910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48911       };
48912     } catch (...) {
48913       {
48914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48915       };
48916     }
48917   }
48918 }
48919
48920
48921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48922   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48923
48924   arg1 = (Dali::Signal< void () > *)jarg1;
48925   {
48926     try {
48927       (arg1)->Emit();
48928     } catch (std::out_of_range& e) {
48929       {
48930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48931       };
48932     } catch (std::exception& e) {
48933       {
48934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48935       };
48936     } catch (...) {
48937       {
48938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48939       };
48940     }
48941   }
48942 }
48943
48944
48945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48946   unsigned int jresult ;
48947   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48948   bool result;
48949
48950   arg1 = (Dali::Signal< void (float) > *)jarg1;
48951   {
48952     try {
48953       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48954     } catch (std::out_of_range& e) {
48955       {
48956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48957       };
48958     } catch (std::exception& e) {
48959       {
48960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48961       };
48962     } catch (...) {
48963       {
48964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48965       };
48966     }
48967   }
48968   jresult = result;
48969   return jresult;
48970 }
48971
48972
48973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48974   unsigned long jresult ;
48975   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48976   std::size_t result;
48977
48978   arg1 = (Dali::Signal< void (float) > *)jarg1;
48979   {
48980     try {
48981       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48982     } catch (std::out_of_range& e) {
48983       {
48984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48985       };
48986     } catch (std::exception& e) {
48987       {
48988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48989       };
48990     } catch (...) {
48991       {
48992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48993       };
48994     }
48995   }
48996   jresult = (unsigned long)result;
48997   return jresult;
48998 }
48999
49000
49001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
49002   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49003   void (*arg2)(float) = (void (*)(float)) 0 ;
49004
49005   arg1 = (Dali::Signal< void (float) > *)jarg1;
49006   arg2 = (void (*)(float))jarg2;
49007   {
49008     try {
49009       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
49010     } catch (std::out_of_range& e) {
49011       {
49012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49013       };
49014     } catch (std::exception& e) {
49015       {
49016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49017       };
49018     } catch (...) {
49019       {
49020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49021       };
49022     }
49023   }
49024 }
49025
49026
49027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49028   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49029   void (*arg2)(float) = (void (*)(float)) 0 ;
49030
49031   arg1 = (Dali::Signal< void (float) > *)jarg1;
49032   arg2 = (void (*)(float))jarg2;
49033   {
49034     try {
49035       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49036     } catch (std::out_of_range& e) {
49037       {
49038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49039       };
49040     } catch (std::exception& e) {
49041       {
49042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49043       };
49044     } catch (...) {
49045       {
49046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49047       };
49048     }
49049   }
49050 }
49051
49052
49053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49054   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49055   float arg2 ;
49056
49057   arg1 = (Dali::Signal< void (float) > *)jarg1;
49058   arg2 = (float)jarg2;
49059   {
49060     try {
49061       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49062     } catch (std::out_of_range& e) {
49063       {
49064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49065       };
49066     } catch (std::exception& e) {
49067       {
49068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49069       };
49070     } catch (...) {
49071       {
49072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49073       };
49074     }
49075   }
49076 }
49077
49078
49079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49080   void * jresult ;
49081   Dali::Signal< void (float) > *result = 0 ;
49082
49083   {
49084     try {
49085       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49086     } catch (std::out_of_range& e) {
49087       {
49088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49089       };
49090     } catch (std::exception& e) {
49091       {
49092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49093       };
49094     } catch (...) {
49095       {
49096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49097       };
49098     }
49099   }
49100   jresult = (void *)result;
49101   return jresult;
49102 }
49103
49104
49105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49106   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49107
49108   arg1 = (Dali::Signal< void (float) > *)jarg1;
49109   {
49110     try {
49111       delete arg1;
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49119       };
49120     } catch (...) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49123       };
49124     }
49125   }
49126 }
49127
49128
49129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49130   unsigned int jresult ;
49131   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49132   bool result;
49133
49134   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49135   {
49136     try {
49137       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49138     } catch (std::out_of_range& e) {
49139       {
49140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49141       };
49142     } catch (std::exception& e) {
49143       {
49144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49145       };
49146     } catch (...) {
49147       {
49148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49149       };
49150     }
49151   }
49152   jresult = result;
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49158   unsigned long jresult ;
49159   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49160   std::size_t result;
49161
49162   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49163   {
49164     try {
49165       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49173       };
49174     } catch (...) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49177       };
49178     }
49179   }
49180   jresult = (unsigned long)result;
49181   return jresult;
49182 }
49183
49184
49185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49186   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49187   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49188
49189   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49190   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49191   {
49192     try {
49193       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49194     } catch (std::out_of_range& e) {
49195       {
49196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49197       };
49198     } catch (std::exception& e) {
49199       {
49200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49201       };
49202     } catch (...) {
49203       {
49204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49205       };
49206     }
49207   }
49208 }
49209
49210
49211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49212   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49213   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49214
49215   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49216   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49217   {
49218     try {
49219       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49220     } catch (std::out_of_range& e) {
49221       {
49222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49223       };
49224     } catch (std::exception& e) {
49225       {
49226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49227       };
49228     } catch (...) {
49229       {
49230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49231       };
49232     }
49233   }
49234 }
49235
49236
49237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49238   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49239   Dali::BaseHandle arg2 ;
49240   Dali::BaseHandle *argp2 ;
49241
49242   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49243   argp2 = (Dali::BaseHandle *)jarg2;
49244   if (!argp2) {
49245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49246     return ;
49247   }
49248   arg2 = *argp2;
49249   {
49250     try {
49251       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49252     } catch (std::out_of_range& e) {
49253       {
49254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49255       };
49256     } catch (std::exception& e) {
49257       {
49258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49259       };
49260     } catch (...) {
49261       {
49262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49263       };
49264     }
49265   }
49266 }
49267
49268
49269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49270   void * jresult ;
49271   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49272
49273   {
49274     try {
49275       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49276     } catch (std::out_of_range& e) {
49277       {
49278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49279       };
49280     } catch (std::exception& e) {
49281       {
49282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (...) {
49285       {
49286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49287       };
49288     }
49289   }
49290   jresult = (void *)result;
49291   return jresult;
49292 }
49293
49294
49295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49296   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49297
49298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49299   {
49300     try {
49301       delete arg1;
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (...) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49313       };
49314     }
49315   }
49316 }
49317
49318
49319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49320   unsigned int jresult ;
49321   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49322   bool result;
49323
49324   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49325   {
49326     try {
49327       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49328     } catch (std::out_of_range& e) {
49329       {
49330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49331       };
49332     } catch (std::exception& e) {
49333       {
49334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49335       };
49336     } catch (...) {
49337       {
49338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49339       };
49340     }
49341   }
49342   jresult = result;
49343   return jresult;
49344 }
49345
49346
49347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49348   unsigned long jresult ;
49349   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49350   std::size_t result;
49351
49352   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49353   {
49354     try {
49355       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49356     } catch (std::out_of_range& e) {
49357       {
49358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49359       };
49360     } catch (std::exception& e) {
49361       {
49362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (...) {
49365       {
49366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49367       };
49368     }
49369   }
49370   jresult = (unsigned long)result;
49371   return jresult;
49372 }
49373
49374
49375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49376   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49377   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49378
49379   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49380   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49381   {
49382     try {
49383       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49384     } catch (std::out_of_range& e) {
49385       {
49386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49387       };
49388     } catch (std::exception& e) {
49389       {
49390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49391       };
49392     } catch (...) {
49393       {
49394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49395       };
49396     }
49397   }
49398 }
49399
49400
49401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49403   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49404
49405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49406   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49407   {
49408     try {
49409       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49410     } catch (std::out_of_range& e) {
49411       {
49412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49413       };
49414     } catch (std::exception& e) {
49415       {
49416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49417       };
49418     } catch (...) {
49419       {
49420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49421       };
49422     }
49423   }
49424 }
49425
49426
49427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49428   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49429   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49430
49431   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49432   arg2 = (Dali::RefObject *)jarg2;
49433   {
49434     try {
49435       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49436     } catch (std::out_of_range& e) {
49437       {
49438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49439       };
49440     } catch (std::exception& e) {
49441       {
49442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49443       };
49444     } catch (...) {
49445       {
49446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49447       };
49448     }
49449   }
49450 }
49451
49452
49453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49454   void * jresult ;
49455   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49456
49457   {
49458     try {
49459       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49460     } catch (std::out_of_range& e) {
49461       {
49462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49463       };
49464     } catch (std::exception& e) {
49465       {
49466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49467       };
49468     } catch (...) {
49469       {
49470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49471       };
49472     }
49473   }
49474   jresult = (void *)result;
49475   return jresult;
49476 }
49477
49478
49479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49480   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49481
49482   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49483   {
49484     try {
49485       delete arg1;
49486     } catch (std::out_of_range& e) {
49487       {
49488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49489       };
49490     } catch (std::exception& e) {
49491       {
49492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49493       };
49494     } catch (...) {
49495       {
49496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49497       };
49498     }
49499   }
49500 }
49501
49502
49503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49504   unsigned int jresult ;
49505   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49506   bool result;
49507
49508   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49509   {
49510     try {
49511       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49512     } catch (std::out_of_range& e) {
49513       {
49514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49515       };
49516     } catch (std::exception& e) {
49517       {
49518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49519       };
49520     } catch (...) {
49521       {
49522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49523       };
49524     }
49525   }
49526   jresult = result;
49527   return jresult;
49528 }
49529
49530
49531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49532   unsigned long jresult ;
49533   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49534   std::size_t result;
49535
49536   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49537   {
49538     try {
49539       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49540     } catch (std::out_of_range& e) {
49541       {
49542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49543       };
49544     } catch (std::exception& e) {
49545       {
49546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (...) {
49549       {
49550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49551       };
49552     }
49553   }
49554   jresult = (unsigned long)result;
49555   return jresult;
49556 }
49557
49558
49559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49560   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49561   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49562
49563   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49564   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49565   {
49566     try {
49567       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49568     } catch (std::out_of_range& e) {
49569       {
49570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49571       };
49572     } catch (std::exception& e) {
49573       {
49574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49575       };
49576     } catch (...) {
49577       {
49578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49579       };
49580     }
49581   }
49582 }
49583
49584
49585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49586   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49587   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49588
49589   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49590   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49591   {
49592     try {
49593       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49594     } catch (std::out_of_range& e) {
49595       {
49596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49597       };
49598     } catch (std::exception& e) {
49599       {
49600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49601       };
49602     } catch (...) {
49603       {
49604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49605       };
49606     }
49607   }
49608 }
49609
49610
49611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49612   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49613   Dali::PropertyNotification *arg2 = 0 ;
49614
49615   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49616   arg2 = (Dali::PropertyNotification *)jarg2;
49617   if (!arg2) {
49618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49619     return ;
49620   }
49621   {
49622     try {
49623       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49624     } catch (std::out_of_range& e) {
49625       {
49626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49627       };
49628     } catch (std::exception& e) {
49629       {
49630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49631       };
49632     } catch (...) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49635       };
49636     }
49637   }
49638 }
49639
49640
49641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49642   void * jresult ;
49643   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49644
49645   {
49646     try {
49647       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49648     } catch (std::out_of_range& e) {
49649       {
49650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49651       };
49652     } catch (std::exception& e) {
49653       {
49654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49655       };
49656     } catch (...) {
49657       {
49658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49659       };
49660     }
49661   }
49662   jresult = (void *)result;
49663   return jresult;
49664 }
49665
49666
49667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49668   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49669
49670   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49671   {
49672     try {
49673       delete arg1;
49674     } catch (std::out_of_range& e) {
49675       {
49676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (std::exception& e) {
49679       {
49680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688 }
49689
49690
49691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49692   unsigned int jresult ;
49693   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49694   bool result;
49695
49696   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49697   {
49698     try {
49699       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49700     } catch (std::out_of_range& e) {
49701       {
49702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49703       };
49704     } catch (std::exception& e) {
49705       {
49706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49707       };
49708     } catch (...) {
49709       {
49710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49711       };
49712     }
49713   }
49714   jresult = result;
49715   return jresult;
49716 }
49717
49718
49719 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49720   unsigned long jresult ;
49721   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49722   std::size_t result;
49723
49724   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49725   {
49726     try {
49727       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49728     } catch (std::out_of_range& e) {
49729       {
49730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49731       };
49732     } catch (std::exception& e) {
49733       {
49734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49735       };
49736     } catch (...) {
49737       {
49738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49739       };
49740     }
49741   }
49742   jresult = (unsigned long)result;
49743   return jresult;
49744 }
49745
49746
49747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49748   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49749   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49750
49751   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49752   arg2 = (void (*)(Dali::Image))jarg2;
49753   {
49754     try {
49755       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (...) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49767       };
49768     }
49769   }
49770 }
49771
49772
49773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49774   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49775   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49776
49777   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49778   arg2 = (void (*)(Dali::Image))jarg2;
49779   {
49780     try {
49781       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49782     } catch (std::out_of_range& e) {
49783       {
49784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49785       };
49786     } catch (std::exception& e) {
49787       {
49788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (...) {
49791       {
49792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49793       };
49794     }
49795   }
49796 }
49797
49798
49799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49800   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49801   Dali::Image arg2 ;
49802   Dali::Image *argp2 ;
49803
49804   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49805   argp2 = (Dali::Image *)jarg2;
49806   if (!argp2) {
49807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49808     return ;
49809   }
49810   arg2 = *argp2;
49811   {
49812     try {
49813       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49814     } catch (std::out_of_range& e) {
49815       {
49816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49817       };
49818     } catch (std::exception& e) {
49819       {
49820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (...) {
49823       {
49824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49825       };
49826     }
49827   }
49828 }
49829
49830
49831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49832   void * jresult ;
49833   Dali::Signal< void (Dali::Image) > *result = 0 ;
49834
49835   {
49836     try {
49837       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49838     } catch (std::out_of_range& e) {
49839       {
49840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49841       };
49842     } catch (std::exception& e) {
49843       {
49844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49845       };
49846     } catch (...) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49849       };
49850     }
49851   }
49852   jresult = (void *)result;
49853   return jresult;
49854 }
49855
49856
49857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49858   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49859
49860   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49861   {
49862     try {
49863       delete arg1;
49864     } catch (std::out_of_range& e) {
49865       {
49866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (std::exception& e) {
49869       {
49870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878 }
49879
49880
49881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49882   void * jresult ;
49883   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49884
49885   {
49886     try {
49887       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49888     } catch (std::out_of_range& e) {
49889       {
49890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49891       };
49892     } catch (std::exception& e) {
49893       {
49894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49895       };
49896     } catch (...) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49899       };
49900     }
49901   }
49902   jresult = (void *)result;
49903   return jresult;
49904 }
49905
49906
49907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49908   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49909
49910   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49911   {
49912     try {
49913       delete arg1;
49914     } catch (std::out_of_range& e) {
49915       {
49916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49917       };
49918     } catch (std::exception& e) {
49919       {
49920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49921       };
49922     } catch (...) {
49923       {
49924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49925       };
49926     }
49927   }
49928 }
49929
49930
49931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49932   unsigned int jresult ;
49933   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49934   bool result;
49935
49936   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49937   {
49938     try {
49939       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);
49940     } catch (std::out_of_range& e) {
49941       {
49942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49943       };
49944     } catch (std::exception& e) {
49945       {
49946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49947       };
49948     } catch (...) {
49949       {
49950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49951       };
49952     }
49953   }
49954   jresult = result;
49955   return jresult;
49956 }
49957
49958
49959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49960   unsigned long jresult ;
49961   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49962   std::size_t result;
49963
49964   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49965   {
49966     try {
49967       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);
49968     } catch (std::out_of_range& e) {
49969       {
49970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49971       };
49972     } catch (std::exception& e) {
49973       {
49974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49975       };
49976     } catch (...) {
49977       {
49978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49979       };
49980     }
49981   }
49982   jresult = (unsigned long)result;
49983   return jresult;
49984 }
49985
49986
49987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49988   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49989   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49990
49991   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49992   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49993   {
49994     try {
49995       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49996     } catch (std::out_of_range& e) {
49997       {
49998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49999       };
50000     } catch (std::exception& e) {
50001       {
50002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50003       };
50004     } catch (...) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50007       };
50008     }
50009   }
50010 }
50011
50012
50013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
50014   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50015   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
50016
50017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50018   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50019   {
50020     try {
50021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50022     } catch (std::out_of_range& e) {
50023       {
50024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50025       };
50026     } catch (std::exception& e) {
50027       {
50028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50029       };
50030     } catch (...) {
50031       {
50032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50033       };
50034     }
50035   }
50036 }
50037
50038
50039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50040   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50041   Dali::Actor arg2 ;
50042   Dali::LongPressGesture *arg3 = 0 ;
50043   Dali::Actor *argp2 ;
50044
50045   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50046   argp2 = (Dali::Actor *)jarg2;
50047   if (!argp2) {
50048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50049     return ;
50050   }
50051   arg2 = *argp2;
50052   arg3 = (Dali::LongPressGesture *)jarg3;
50053   if (!arg3) {
50054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50055     return ;
50056   }
50057   {
50058     try {
50059       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50067       };
50068     } catch (...) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50071       };
50072     }
50073   }
50074 }
50075
50076
50077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50078   void * jresult ;
50079   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50080
50081   {
50082     try {
50083       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50084     } catch (std::out_of_range& e) {
50085       {
50086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50087       };
50088     } catch (std::exception& e) {
50089       {
50090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50091       };
50092     } catch (...) {
50093       {
50094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50095       };
50096     }
50097   }
50098   jresult = (void *)result;
50099   return jresult;
50100 }
50101
50102
50103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50104   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50105
50106   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50107   {
50108     try {
50109       delete arg1;
50110     } catch (std::out_of_range& e) {
50111       {
50112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50113       };
50114     } catch (std::exception& e) {
50115       {
50116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50117       };
50118     } catch (...) {
50119       {
50120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50121       };
50122     }
50123   }
50124 }
50125
50126
50127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50128   unsigned int jresult ;
50129   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50130   bool result;
50131
50132   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50133   {
50134     try {
50135       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);
50136     } catch (std::out_of_range& e) {
50137       {
50138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (std::exception& e) {
50141       {
50142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50147       };
50148     }
50149   }
50150   jresult = result;
50151   return jresult;
50152 }
50153
50154
50155 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50156   unsigned long jresult ;
50157   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50158   std::size_t result;
50159
50160   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50161   {
50162     try {
50163       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);
50164     } catch (std::out_of_range& e) {
50165       {
50166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50167       };
50168     } catch (std::exception& e) {
50169       {
50170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50171       };
50172     } catch (...) {
50173       {
50174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50175       };
50176     }
50177   }
50178   jresult = (unsigned long)result;
50179   return jresult;
50180 }
50181
50182
50183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50184   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50185   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50186
50187   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50188   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50189   {
50190     try {
50191       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50192     } catch (std::out_of_range& e) {
50193       {
50194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50195       };
50196     } catch (std::exception& e) {
50197       {
50198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (...) {
50201       {
50202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50203       };
50204     }
50205   }
50206 }
50207
50208
50209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50210   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50211   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50212
50213   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50214   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50215   {
50216     try {
50217       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50218     } catch (std::out_of_range& e) {
50219       {
50220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50221       };
50222     } catch (std::exception& e) {
50223       {
50224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50225       };
50226     } catch (...) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50229       };
50230     }
50231   }
50232 }
50233
50234
50235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50236   unsigned int jresult ;
50237   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50238   Dali::Actor arg2 ;
50239   Dali::TouchData *arg3 = 0 ;
50240   Dali::Actor *argp2 ;
50241   bool result;
50242
50243   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50244   argp2 = (Dali::Actor *)jarg2;
50245   if (!argp2) {
50246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50247     return 0;
50248   }
50249   arg2 = *argp2;
50250   arg3 = (Dali::TouchData *)jarg3;
50251   if (!arg3) {
50252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50253     return 0;
50254   }
50255   {
50256     try {
50257       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50258     } catch (std::out_of_range& e) {
50259       {
50260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50261       };
50262     } catch (std::exception& e) {
50263       {
50264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50265       };
50266     } catch (...) {
50267       {
50268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50269       };
50270     }
50271   }
50272   jresult = result;
50273   return jresult;
50274 }
50275
50276
50277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50278   void * jresult ;
50279   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50280
50281   {
50282     try {
50283       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50284     } catch (std::out_of_range& e) {
50285       {
50286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50287       };
50288     } catch (std::exception& e) {
50289       {
50290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (...) {
50293       {
50294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50295       };
50296     }
50297   }
50298   jresult = (void *)result;
50299   return jresult;
50300 }
50301
50302
50303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50304   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50305
50306   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50307   {
50308     try {
50309       delete arg1;
50310     } catch (std::out_of_range& e) {
50311       {
50312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50313       };
50314     } catch (std::exception& e) {
50315       {
50316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50317       };
50318     } catch (...) {
50319       {
50320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50321       };
50322     }
50323   }
50324 }
50325
50326
50327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50328   unsigned int jresult ;
50329   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50330   bool result;
50331
50332   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50333   {
50334     try {
50335       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);
50336     } catch (std::out_of_range& e) {
50337       {
50338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50339       };
50340     } catch (std::exception& e) {
50341       {
50342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50343       };
50344     } catch (...) {
50345       {
50346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50347       };
50348     }
50349   }
50350   jresult = result;
50351   return jresult;
50352 }
50353
50354
50355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50356   unsigned long jresult ;
50357   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50358   std::size_t result;
50359
50360   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50361   {
50362     try {
50363       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);
50364     } catch (std::out_of_range& e) {
50365       {
50366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50367       };
50368     } catch (std::exception& e) {
50369       {
50370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50371       };
50372     } catch (...) {
50373       {
50374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50375       };
50376     }
50377   }
50378   jresult = (unsigned long)result;
50379   return jresult;
50380 }
50381
50382
50383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50384   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50385   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50386
50387   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50388   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50389   {
50390     try {
50391       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50392     } catch (std::out_of_range& e) {
50393       {
50394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50395       };
50396     } catch (std::exception& e) {
50397       {
50398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50399       };
50400     } catch (...) {
50401       {
50402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50403       };
50404     }
50405   }
50406 }
50407
50408
50409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50410   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50411   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50412
50413   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50414   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50415   {
50416     try {
50417       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50418     } catch (std::out_of_range& e) {
50419       {
50420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50421       };
50422     } catch (std::exception& e) {
50423       {
50424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50425       };
50426     } catch (...) {
50427       {
50428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50429       };
50430     }
50431   }
50432 }
50433
50434
50435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50436   unsigned int jresult ;
50437   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50438   Dali::Actor arg2 ;
50439   Dali::HoverEvent *arg3 = 0 ;
50440   Dali::Actor *argp2 ;
50441   bool result;
50442
50443   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50444   argp2 = (Dali::Actor *)jarg2;
50445   if (!argp2) {
50446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50447     return 0;
50448   }
50449   arg2 = *argp2;
50450   arg3 = (Dali::HoverEvent *)jarg3;
50451   if (!arg3) {
50452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50453     return 0;
50454   }
50455   {
50456     try {
50457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50458     } catch (std::out_of_range& e) {
50459       {
50460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50461       };
50462     } catch (std::exception& e) {
50463       {
50464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (...) {
50467       {
50468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50469       };
50470     }
50471   }
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50478   void * jresult ;
50479   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50480
50481   {
50482     try {
50483       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50484     } catch (std::out_of_range& e) {
50485       {
50486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50487       };
50488     } catch (std::exception& e) {
50489       {
50490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (...) {
50493       {
50494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50495       };
50496     }
50497   }
50498   jresult = (void *)result;
50499   return jresult;
50500 }
50501
50502
50503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50504   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50505
50506   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50507   {
50508     try {
50509       delete arg1;
50510     } catch (std::out_of_range& e) {
50511       {
50512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50513       };
50514     } catch (std::exception& e) {
50515       {
50516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50517       };
50518     } catch (...) {
50519       {
50520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50521       };
50522     }
50523   }
50524 }
50525
50526
50527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50528   unsigned int jresult ;
50529   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50530   bool result;
50531
50532   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50533   {
50534     try {
50535       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);
50536     } catch (std::out_of_range& e) {
50537       {
50538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50539       };
50540     } catch (std::exception& e) {
50541       {
50542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50543       };
50544     } catch (...) {
50545       {
50546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50547       };
50548     }
50549   }
50550   jresult = result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50556   unsigned long jresult ;
50557   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50558   std::size_t result;
50559
50560   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50561   {
50562     try {
50563       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);
50564     } catch (std::out_of_range& e) {
50565       {
50566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50567       };
50568     } catch (std::exception& e) {
50569       {
50570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50571       };
50572     } catch (...) {
50573       {
50574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50575       };
50576     }
50577   }
50578   jresult = (unsigned long)result;
50579   return jresult;
50580 }
50581
50582
50583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50584   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50585   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50586
50587   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50588   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50589   {
50590     try {
50591       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50592     } catch (std::out_of_range& e) {
50593       {
50594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50595       };
50596     } catch (std::exception& e) {
50597       {
50598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50599       };
50600     } catch (...) {
50601       {
50602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50603       };
50604     }
50605   }
50606 }
50607
50608
50609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50610   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50611   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50612
50613   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50614   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50615   {
50616     try {
50617       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50618     } catch (std::out_of_range& e) {
50619       {
50620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50621       };
50622     } catch (std::exception& e) {
50623       {
50624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50625       };
50626     } catch (...) {
50627       {
50628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50629       };
50630     }
50631   }
50632 }
50633
50634
50635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50636   unsigned int jresult ;
50637   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50638   Dali::Actor arg2 ;
50639   Dali::WheelEvent *arg3 = 0 ;
50640   Dali::Actor *argp2 ;
50641   bool result;
50642
50643   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50644   argp2 = (Dali::Actor *)jarg2;
50645   if (!argp2) {
50646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50647     return 0;
50648   }
50649   arg2 = *argp2;
50650   arg3 = (Dali::WheelEvent *)jarg3;
50651   if (!arg3) {
50652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50653     return 0;
50654   }
50655   {
50656     try {
50657       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50658     } catch (std::out_of_range& e) {
50659       {
50660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50661       };
50662     } catch (std::exception& e) {
50663       {
50664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50665       };
50666     } catch (...) {
50667       {
50668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50669       };
50670     }
50671   }
50672   jresult = result;
50673   return jresult;
50674 }
50675
50676
50677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50678   void * jresult ;
50679   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50680
50681   {
50682     try {
50683       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50684     } catch (std::out_of_range& e) {
50685       {
50686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50687       };
50688     } catch (std::exception& e) {
50689       {
50690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (...) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50695       };
50696     }
50697   }
50698   jresult = (void *)result;
50699   return jresult;
50700 }
50701
50702
50703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50704   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50705
50706   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50707   {
50708     try {
50709       delete arg1;
50710     } catch (std::out_of_range& e) {
50711       {
50712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50713       };
50714     } catch (std::exception& e) {
50715       {
50716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50717       };
50718     } catch (...) {
50719       {
50720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50721       };
50722     }
50723   }
50724 }
50725
50726
50727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50728   unsigned int jresult ;
50729   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50730   bool result;
50731
50732   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50733   {
50734     try {
50735       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50736     } catch (std::out_of_range& e) {
50737       {
50738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50739       };
50740     } catch (std::exception& e) {
50741       {
50742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50743       };
50744     } catch (...) {
50745       {
50746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50747       };
50748     }
50749   }
50750   jresult = result;
50751   return jresult;
50752 }
50753
50754
50755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50756   unsigned long jresult ;
50757   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50758   std::size_t result;
50759
50760   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50761   {
50762     try {
50763       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50764     } catch (std::out_of_range& e) {
50765       {
50766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50767       };
50768     } catch (std::exception& e) {
50769       {
50770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50771       };
50772     } catch (...) {
50773       {
50774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50775       };
50776     }
50777   }
50778   jresult = (unsigned long)result;
50779   return jresult;
50780 }
50781
50782
50783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50784   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50785   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50786
50787   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50788   arg2 = (void (*)(Dali::Actor))jarg2;
50789   {
50790     try {
50791       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50792     } catch (std::out_of_range& e) {
50793       {
50794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50795       };
50796     } catch (std::exception& e) {
50797       {
50798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50799       };
50800     } catch (...) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50803       };
50804     }
50805   }
50806 }
50807
50808
50809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50810   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50811   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50812
50813   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50814   arg2 = (void (*)(Dali::Actor))jarg2;
50815   {
50816     try {
50817       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50818     } catch (std::out_of_range& e) {
50819       {
50820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50821       };
50822     } catch (std::exception& e) {
50823       {
50824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50825       };
50826     } catch (...) {
50827       {
50828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50829       };
50830     }
50831   }
50832 }
50833
50834
50835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50836   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50837   Dali::Actor arg2 ;
50838   Dali::Actor *argp2 ;
50839
50840   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50841   argp2 = (Dali::Actor *)jarg2;
50842   if (!argp2) {
50843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50844     return ;
50845   }
50846   arg2 = *argp2;
50847   {
50848     try {
50849       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50850     } catch (std::out_of_range& e) {
50851       {
50852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50853       };
50854     } catch (std::exception& e) {
50855       {
50856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50857       };
50858     } catch (...) {
50859       {
50860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50861       };
50862     }
50863   }
50864 }
50865
50866
50867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50868   void * jresult ;
50869   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50870
50871   {
50872     try {
50873       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50874     } catch (std::out_of_range& e) {
50875       {
50876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50877       };
50878     } catch (std::exception& e) {
50879       {
50880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50881       };
50882     } catch (...) {
50883       {
50884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50885       };
50886     }
50887   }
50888   jresult = (void *)result;
50889   return jresult;
50890 }
50891
50892
50893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50894   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50895
50896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50897   {
50898     try {
50899       delete arg1;
50900     } catch (std::out_of_range& e) {
50901       {
50902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50903       };
50904     } catch (std::exception& e) {
50905       {
50906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50907       };
50908     } catch (...) {
50909       {
50910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50911       };
50912     }
50913   }
50914 }
50915
50916
50917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50918   unsigned int jresult ;
50919   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50920   bool result;
50921
50922   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50923   {
50924     try {
50925       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50926     } catch (std::out_of_range& e) {
50927       {
50928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50929       };
50930     } catch (std::exception& e) {
50931       {
50932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50933       };
50934     } catch (...) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50937       };
50938     }
50939   }
50940   jresult = result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50946   unsigned long jresult ;
50947   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50948   std::size_t result;
50949
50950   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50951   {
50952     try {
50953       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50954     } catch (std::out_of_range& e) {
50955       {
50956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50957       };
50958     } catch (std::exception& e) {
50959       {
50960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50961       };
50962     } catch (...) {
50963       {
50964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50965       };
50966     }
50967   }
50968   jresult = (unsigned long)result;
50969   return jresult;
50970 }
50971
50972
50973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50974   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50975   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50976
50977   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50978   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50979   {
50980     try {
50981       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50982     } catch (std::out_of_range& e) {
50983       {
50984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50985       };
50986     } catch (std::exception& e) {
50987       {
50988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50989       };
50990     } catch (...) {
50991       {
50992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50993       };
50994     }
50995   }
50996 }
50997
50998
50999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
51000   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51001   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
51002
51003   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51004   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
51005   {
51006     try {
51007       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51008     } catch (std::out_of_range& e) {
51009       {
51010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51011       };
51012     } catch (std::exception& e) {
51013       {
51014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51015       };
51016     } catch (...) {
51017       {
51018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51019       };
51020     }
51021   }
51022 }
51023
51024
51025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51026   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51027   Dali::KeyEvent *arg2 = 0 ;
51028
51029   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51030   arg2 = (Dali::KeyEvent *)jarg2;
51031   if (!arg2) {
51032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51033     return ;
51034   }
51035   {
51036     try {
51037       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51038     } catch (std::out_of_range& e) {
51039       {
51040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51041       };
51042     } catch (std::exception& e) {
51043       {
51044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51045       };
51046     } catch (...) {
51047       {
51048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51049       };
51050     }
51051   }
51052 }
51053
51054
51055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51056   void * jresult ;
51057   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51058
51059   {
51060     try {
51061       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51062     } catch (std::out_of_range& e) {
51063       {
51064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51065       };
51066     } catch (std::exception& e) {
51067       {
51068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51069       };
51070     } catch (...) {
51071       {
51072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51073       };
51074     }
51075   }
51076   jresult = (void *)result;
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51082   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51083
51084   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51085   {
51086     try {
51087       delete arg1;
51088     } catch (std::out_of_range& e) {
51089       {
51090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51091       };
51092     } catch (std::exception& e) {
51093       {
51094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51095       };
51096     } catch (...) {
51097       {
51098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51099       };
51100     }
51101   }
51102 }
51103
51104
51105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51106   unsigned int jresult ;
51107   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51108   bool result;
51109
51110   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51111   {
51112     try {
51113       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
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 = result;
51129   return jresult;
51130 }
51131
51132
51133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51134   unsigned long jresult ;
51135   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51136   std::size_t result;
51137
51138   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51139   {
51140     try {
51141       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)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 = (unsigned long)result;
51157   return jresult;
51158 }
51159
51160
51161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51162   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51163   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51164
51165   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51166   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51167   {
51168     try {
51169       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51170     } catch (std::out_of_range& e) {
51171       {
51172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51173       };
51174     } catch (std::exception& e) {
51175       {
51176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51177       };
51178     } catch (...) {
51179       {
51180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51181       };
51182     }
51183   }
51184 }
51185
51186
51187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51188   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51189   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51190
51191   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51192   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51193   {
51194     try {
51195       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51196     } catch (std::out_of_range& e) {
51197       {
51198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51199       };
51200     } catch (std::exception& e) {
51201       {
51202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (...) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51207       };
51208     }
51209   }
51210 }
51211
51212
51213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51214   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51215   Dali::TouchData *arg2 = 0 ;
51216
51217   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51218   arg2 = (Dali::TouchData *)jarg2;
51219   if (!arg2) {
51220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51221     return ;
51222   }
51223   {
51224     try {
51225       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51226     } catch (std::out_of_range& e) {
51227       {
51228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51229       };
51230     } catch (std::exception& e) {
51231       {
51232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51233       };
51234     } catch (...) {
51235       {
51236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51237       };
51238     }
51239   }
51240 }
51241
51242
51243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51244   void * jresult ;
51245   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51246
51247   {
51248     try {
51249       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51250     } catch (std::out_of_range& e) {
51251       {
51252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51253       };
51254     } catch (std::exception& e) {
51255       {
51256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51257       };
51258     } catch (...) {
51259       {
51260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51261       };
51262     }
51263   }
51264   jresult = (void *)result;
51265   return jresult;
51266 }
51267
51268
51269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51270   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51271
51272   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51273   {
51274     try {
51275       delete arg1;
51276     } catch (std::out_of_range& e) {
51277       {
51278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (std::exception& e) {
51281       {
51282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (...) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51287       };
51288     }
51289   }
51290 }
51291
51292
51293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51294   unsigned int jresult ;
51295   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51296   bool result;
51297
51298   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51299   {
51300     try {
51301       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51302     } catch (std::out_of_range& e) {
51303       {
51304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51305       };
51306     } catch (std::exception& e) {
51307       {
51308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51313       };
51314     }
51315   }
51316   jresult = result;
51317   return jresult;
51318 }
51319
51320
51321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51322   unsigned long jresult ;
51323   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51324   std::size_t result;
51325
51326   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51327   {
51328     try {
51329       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51330     } catch (std::out_of_range& e) {
51331       {
51332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51333       };
51334     } catch (std::exception& e) {
51335       {
51336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51337       };
51338     } catch (...) {
51339       {
51340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51341       };
51342     }
51343   }
51344   jresult = (unsigned long)result;
51345   return jresult;
51346 }
51347
51348
51349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51350   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51351   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51352
51353   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51354   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51355   {
51356     try {
51357       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51358     } catch (std::out_of_range& e) {
51359       {
51360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51361       };
51362     } catch (std::exception& e) {
51363       {
51364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (...) {
51367       {
51368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51369       };
51370     }
51371   }
51372 }
51373
51374
51375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51376   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51377   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51378
51379   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51380   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51381   {
51382     try {
51383       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51384     } catch (std::out_of_range& e) {
51385       {
51386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51387       };
51388     } catch (std::exception& e) {
51389       {
51390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51391       };
51392     } catch (...) {
51393       {
51394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51395       };
51396     }
51397   }
51398 }
51399
51400
51401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51402   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51403   Dali::WheelEvent *arg2 = 0 ;
51404
51405   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51406   arg2 = (Dali::WheelEvent *)jarg2;
51407   if (!arg2) {
51408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51409     return ;
51410   }
51411   {
51412     try {
51413       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51414     } catch (std::out_of_range& e) {
51415       {
51416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51417       };
51418     } catch (std::exception& e) {
51419       {
51420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51421       };
51422     } catch (...) {
51423       {
51424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51425       };
51426     }
51427   }
51428 }
51429
51430
51431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51432   void * jresult ;
51433   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51434
51435   {
51436     try {
51437       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51445       };
51446     } catch (...) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51449       };
51450     }
51451   }
51452   jresult = (void *)result;
51453   return jresult;
51454 }
51455
51456
51457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51458   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51459
51460   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51461   {
51462     try {
51463       delete arg1;
51464     } catch (std::out_of_range& e) {
51465       {
51466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51467       };
51468     } catch (std::exception& e) {
51469       {
51470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51471       };
51472     } catch (...) {
51473       {
51474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51475       };
51476     }
51477   }
51478 }
51479
51480
51481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51482   void * jresult ;
51483   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51484
51485   {
51486     try {
51487       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51488     } catch (std::out_of_range& e) {
51489       {
51490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51491       };
51492     } catch (std::exception& e) {
51493       {
51494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51499       };
51500     }
51501   }
51502   jresult = (void *)result;
51503   return jresult;
51504 }
51505
51506
51507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51508   void * jresult ;
51509   Dali::Radian arg1 ;
51510   Dali::Radian arg2 ;
51511   Dali::Radian *argp1 ;
51512   Dali::Radian *argp2 ;
51513   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51514
51515   argp1 = (Dali::Radian *)jarg1;
51516   if (!argp1) {
51517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51518     return 0;
51519   }
51520   arg1 = *argp1;
51521   argp2 = (Dali::Radian *)jarg2;
51522   if (!argp2) {
51523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51524     return 0;
51525   }
51526   arg2 = *argp2;
51527   {
51528     try {
51529       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51530     } catch (std::out_of_range& e) {
51531       {
51532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51533       };
51534     } catch (std::exception& e) {
51535       {
51536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51537       };
51538     } catch (...) {
51539       {
51540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51541       };
51542     }
51543   }
51544   jresult = (void *)result;
51545   return jresult;
51546 }
51547
51548
51549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51550   void * jresult ;
51551   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51552   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51553
51554   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51555   if (!arg1) {
51556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51557     return 0;
51558   }
51559   {
51560     try {
51561       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51562     } catch (std::out_of_range& e) {
51563       {
51564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51565       };
51566     } catch (std::exception& e) {
51567       {
51568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (...) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51573       };
51574     }
51575   }
51576   jresult = (void *)result;
51577   return jresult;
51578 }
51579
51580
51581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51582   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51583   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51584
51585   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51586   arg2 = (Dali::Radian *)jarg2;
51587   if (arg1) (arg1)->first = *arg2;
51588 }
51589
51590
51591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51592   void * jresult ;
51593   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51594   Dali::Radian *result = 0 ;
51595
51596   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51597   result = (Dali::Radian *)& ((arg1)->first);
51598   jresult = (void *)result;
51599   return jresult;
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51604   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51605   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51606
51607   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51608   arg2 = (Dali::Radian *)jarg2;
51609   if (arg1) (arg1)->second = *arg2;
51610 }
51611
51612
51613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51614   void * jresult ;
51615   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51616   Dali::Radian *result = 0 ;
51617
51618   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51619   result = (Dali::Radian *)& ((arg1)->second);
51620   jresult = (void *)result;
51621   return jresult;
51622 }
51623
51624
51625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51626   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51627
51628   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51629   {
51630     try {
51631       delete arg1;
51632     } catch (std::out_of_range& e) {
51633       {
51634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (std::exception& e) {
51637       {
51638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51643       };
51644     }
51645   }
51646 }
51647
51648
51649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51650   unsigned int jresult ;
51651   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51652   bool result;
51653
51654   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51655   {
51656     try {
51657       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);
51658     } catch (std::out_of_range& e) {
51659       {
51660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51661       };
51662     } catch (std::exception& e) {
51663       {
51664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51665       };
51666     } catch (...) {
51667       {
51668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51669       };
51670     }
51671   }
51672   jresult = result;
51673   return jresult;
51674 }
51675
51676
51677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51678   unsigned long jresult ;
51679   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51680   std::size_t result;
51681
51682   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51683   {
51684     try {
51685       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);
51686     } catch (std::out_of_range& e) {
51687       {
51688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51689       };
51690     } catch (std::exception& e) {
51691       {
51692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51693       };
51694     } catch (...) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51697       };
51698     }
51699   }
51700   jresult = (unsigned long)result;
51701   return jresult;
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51706   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51707   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51708
51709   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51710   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51711   {
51712     try {
51713       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51714     } catch (std::out_of_range& e) {
51715       {
51716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (std::exception& e) {
51719       {
51720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (...) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51725       };
51726     }
51727   }
51728 }
51729
51730
51731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51732   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51733   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51734
51735   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51736   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51737   {
51738     try {
51739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51740     } catch (std::out_of_range& e) {
51741       {
51742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51743       };
51744     } catch (std::exception& e) {
51745       {
51746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51747       };
51748     } catch (...) {
51749       {
51750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51751       };
51752     }
51753   }
51754 }
51755
51756
51757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51758   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51759   Dali::Actor arg2 ;
51760   Dali::PanGesture *arg3 = 0 ;
51761   Dali::Actor *argp2 ;
51762
51763   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51764   argp2 = (Dali::Actor *)jarg2;
51765   if (!argp2) {
51766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51767     return ;
51768   }
51769   arg2 = *argp2;
51770   arg3 = (Dali::PanGesture *)jarg3;
51771   if (!arg3) {
51772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51773     return ;
51774   }
51775   {
51776     try {
51777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51785       };
51786     } catch (...) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51789       };
51790     }
51791   }
51792 }
51793
51794
51795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51796   void * jresult ;
51797   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51798
51799   {
51800     try {
51801       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51802     } catch (std::out_of_range& e) {
51803       {
51804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51805       };
51806     } catch (std::exception& e) {
51807       {
51808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51809       };
51810     } catch (...) {
51811       {
51812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51813       };
51814     }
51815   }
51816   jresult = (void *)result;
51817   return jresult;
51818 }
51819
51820
51821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51822   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51823
51824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51825   {
51826     try {
51827       delete arg1;
51828     } catch (std::out_of_range& e) {
51829       {
51830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51831       };
51832     } catch (std::exception& e) {
51833       {
51834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51835       };
51836     } catch (...) {
51837       {
51838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51839       };
51840     }
51841   }
51842 }
51843
51844
51845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51846   unsigned int jresult ;
51847   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51848   bool result;
51849
51850   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51851   {
51852     try {
51853       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);
51854     } catch (std::out_of_range& e) {
51855       {
51856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51857       };
51858     } catch (std::exception& e) {
51859       {
51860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51861       };
51862     } catch (...) {
51863       {
51864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51865       };
51866     }
51867   }
51868   jresult = result;
51869   return jresult;
51870 }
51871
51872
51873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51874   unsigned long jresult ;
51875   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51876   std::size_t result;
51877
51878   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51879   {
51880     try {
51881       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);
51882     } catch (std::out_of_range& e) {
51883       {
51884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51885       };
51886     } catch (std::exception& e) {
51887       {
51888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (...) {
51891       {
51892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51893       };
51894     }
51895   }
51896   jresult = (unsigned long)result;
51897   return jresult;
51898 }
51899
51900
51901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51902   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51903   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51904
51905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51906   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51907   {
51908     try {
51909       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51910     } catch (std::out_of_range& e) {
51911       {
51912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51913       };
51914     } catch (std::exception& e) {
51915       {
51916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (...) {
51919       {
51920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51921       };
51922     }
51923   }
51924 }
51925
51926
51927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51928   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51929   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51930
51931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51932   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51933   {
51934     try {
51935       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51936     } catch (std::out_of_range& e) {
51937       {
51938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51939       };
51940     } catch (std::exception& e) {
51941       {
51942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51943       };
51944     } catch (...) {
51945       {
51946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51947       };
51948     }
51949   }
51950 }
51951
51952
51953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51954   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51955   Dali::Actor arg2 ;
51956   Dali::PinchGesture *arg3 = 0 ;
51957   Dali::Actor *argp2 ;
51958
51959   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51960   argp2 = (Dali::Actor *)jarg2;
51961   if (!argp2) {
51962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51963     return ;
51964   }
51965   arg2 = *argp2;
51966   arg3 = (Dali::PinchGesture *)jarg3;
51967   if (!arg3) {
51968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51969     return ;
51970   }
51971   {
51972     try {
51973       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51974     } catch (std::out_of_range& e) {
51975       {
51976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51977       };
51978     } catch (std::exception& e) {
51979       {
51980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51981       };
51982     } catch (...) {
51983       {
51984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51985       };
51986     }
51987   }
51988 }
51989
51990
51991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51992   void * jresult ;
51993   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51994
51995   {
51996     try {
51997       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51998     } catch (std::out_of_range& e) {
51999       {
52000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52001       };
52002     } catch (std::exception& e) {
52003       {
52004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52005       };
52006     } catch (...) {
52007       {
52008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52009       };
52010     }
52011   }
52012   jresult = (void *)result;
52013   return jresult;
52014 }
52015
52016
52017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52018   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52019
52020   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52021   {
52022     try {
52023       delete arg1;
52024     } catch (std::out_of_range& e) {
52025       {
52026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (std::exception& e) {
52029       {
52030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (...) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52035       };
52036     }
52037   }
52038 }
52039
52040
52041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52042   unsigned int jresult ;
52043   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52044   bool result;
52045
52046   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52047   {
52048     try {
52049       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);
52050     } catch (std::out_of_range& e) {
52051       {
52052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52053       };
52054     } catch (std::exception& e) {
52055       {
52056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52057       };
52058     } catch (...) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52061       };
52062     }
52063   }
52064   jresult = result;
52065   return jresult;
52066 }
52067
52068
52069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52070   unsigned long jresult ;
52071   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52072   std::size_t result;
52073
52074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52075   {
52076     try {
52077       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);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52085       };
52086     } catch (...) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52089       };
52090     }
52091   }
52092   jresult = (unsigned long)result;
52093   return jresult;
52094 }
52095
52096
52097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52098   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52099   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52100
52101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52102   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52103   {
52104     try {
52105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52106     } catch (std::out_of_range& e) {
52107       {
52108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (std::exception& e) {
52111       {
52112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (...) {
52115       {
52116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52117       };
52118     }
52119   }
52120 }
52121
52122
52123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52124   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52125   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52126
52127   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52128   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52129   {
52130     try {
52131       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52132     } catch (std::out_of_range& e) {
52133       {
52134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52135       };
52136     } catch (std::exception& e) {
52137       {
52138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52139       };
52140     } catch (...) {
52141       {
52142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52143       };
52144     }
52145   }
52146 }
52147
52148
52149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52150   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52151   Dali::Actor arg2 ;
52152   Dali::TapGesture *arg3 = 0 ;
52153   Dali::Actor *argp2 ;
52154
52155   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52156   argp2 = (Dali::Actor *)jarg2;
52157   if (!argp2) {
52158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52159     return ;
52160   }
52161   arg2 = *argp2;
52162   arg3 = (Dali::TapGesture *)jarg3;
52163   if (!arg3) {
52164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52165     return ;
52166   }
52167   {
52168     try {
52169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52170     } catch (std::out_of_range& e) {
52171       {
52172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52173       };
52174     } catch (std::exception& e) {
52175       {
52176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52177       };
52178     } catch (...) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52181       };
52182     }
52183   }
52184 }
52185
52186
52187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52188   void * jresult ;
52189   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52190
52191   {
52192     try {
52193       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52194     } catch (std::out_of_range& e) {
52195       {
52196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52197       };
52198     } catch (std::exception& e) {
52199       {
52200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52201       };
52202     } catch (...) {
52203       {
52204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52205       };
52206     }
52207   }
52208   jresult = (void *)result;
52209   return jresult;
52210 }
52211
52212
52213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52214   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52215
52216   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52217   {
52218     try {
52219       delete arg1;
52220     } catch (std::out_of_range& e) {
52221       {
52222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52223       };
52224     } catch (std::exception& e) {
52225       {
52226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52231       };
52232     }
52233   }
52234 }
52235
52236
52237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52238   unsigned int jresult ;
52239   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52240   bool result;
52241
52242   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52243   {
52244     try {
52245       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52246     } catch (std::out_of_range& e) {
52247       {
52248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (std::exception& e) {
52251       {
52252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (...) {
52255       {
52256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52257       };
52258     }
52259   }
52260   jresult = result;
52261   return jresult;
52262 }
52263
52264
52265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52266   unsigned long jresult ;
52267   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52268   std::size_t result;
52269
52270   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52271   {
52272     try {
52273       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52274     } catch (std::out_of_range& e) {
52275       {
52276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52277       };
52278     } catch (std::exception& e) {
52279       {
52280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52281       };
52282     } catch (...) {
52283       {
52284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52285       };
52286     }
52287   }
52288   jresult = (unsigned long)result;
52289   return jresult;
52290 }
52291
52292
52293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52294   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52295   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52296
52297   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52298   arg2 = (void (*)(Dali::Animation &))jarg2;
52299   {
52300     try {
52301       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52302     } catch (std::out_of_range& e) {
52303       {
52304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (std::exception& e) {
52307       {
52308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52309       };
52310     } catch (...) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52313       };
52314     }
52315   }
52316 }
52317
52318
52319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52320   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52321   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52322
52323   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52324   arg2 = (void (*)(Dali::Animation &))jarg2;
52325   {
52326     try {
52327       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52328     } catch (std::out_of_range& e) {
52329       {
52330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52331       };
52332     } catch (std::exception& e) {
52333       {
52334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52335       };
52336     } catch (...) {
52337       {
52338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52339       };
52340     }
52341   }
52342 }
52343
52344
52345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52346   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52347   Dali::Animation *arg2 = 0 ;
52348
52349   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52350   arg2 = (Dali::Animation *)jarg2;
52351   if (!arg2) {
52352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52353     return ;
52354   }
52355   {
52356     try {
52357       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (...) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52369       };
52370     }
52371   }
52372 }
52373
52374
52375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52376   void * jresult ;
52377   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52378
52379   {
52380     try {
52381       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52382     } catch (std::out_of_range& e) {
52383       {
52384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52385       };
52386     } catch (std::exception& e) {
52387       {
52388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (...) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52393       };
52394     }
52395   }
52396   jresult = (void *)result;
52397   return jresult;
52398 }
52399
52400
52401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52402   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52403
52404   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52405   {
52406     try {
52407       delete arg1;
52408     } catch (std::out_of_range& e) {
52409       {
52410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52411       };
52412     } catch (std::exception& e) {
52413       {
52414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52415       };
52416     } catch (...) {
52417       {
52418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52419       };
52420     }
52421   }
52422 }
52423
52424
52425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52426   unsigned int jresult ;
52427   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52428   bool result;
52429
52430   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52431   {
52432     try {
52433       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52434     } catch (std::out_of_range& e) {
52435       {
52436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (std::exception& e) {
52439       {
52440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (...) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52445       };
52446     }
52447   }
52448   jresult = result;
52449   return jresult;
52450 }
52451
52452
52453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52454   unsigned long jresult ;
52455   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52456   std::size_t result;
52457
52458   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52459   {
52460     try {
52461       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52462     } catch (std::out_of_range& e) {
52463       {
52464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52465       };
52466     } catch (std::exception& e) {
52467       {
52468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52469       };
52470     } catch (...) {
52471       {
52472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52473       };
52474     }
52475   }
52476   jresult = (unsigned long)result;
52477   return jresult;
52478 }
52479
52480
52481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52482   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52483   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52484
52485   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52486   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52487   {
52488     try {
52489       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52490     } catch (std::out_of_range& e) {
52491       {
52492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52493       };
52494     } catch (std::exception& e) {
52495       {
52496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52497       };
52498     } catch (...) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52501       };
52502     }
52503   }
52504 }
52505
52506
52507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52508   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52509   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52510
52511   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52512   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52513   {
52514     try {
52515       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52523       };
52524     } catch (...) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52527       };
52528     }
52529   }
52530 }
52531
52532
52533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52534   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52535   Dali::ResourceImage arg2 ;
52536   Dali::ResourceImage *argp2 ;
52537
52538   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52539   argp2 = (Dali::ResourceImage *)jarg2;
52540   if (!argp2) {
52541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52542     return ;
52543   }
52544   arg2 = *argp2;
52545   {
52546     try {
52547       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52548     } catch (std::out_of_range& e) {
52549       {
52550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52551       };
52552     } catch (std::exception& e) {
52553       {
52554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52555       };
52556     } catch (...) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52559       };
52560     }
52561   }
52562 }
52563
52564
52565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52566   void * jresult ;
52567   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52568
52569   {
52570     try {
52571       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52572     } catch (std::out_of_range& e) {
52573       {
52574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52575       };
52576     } catch (std::exception& e) {
52577       {
52578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52583       };
52584     }
52585   }
52586   jresult = (void *)result;
52587   return jresult;
52588 }
52589
52590
52591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52592   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52593
52594   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52595   {
52596     try {
52597       delete arg1;
52598     } catch (std::out_of_range& e) {
52599       {
52600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52601       };
52602     } catch (std::exception& e) {
52603       {
52604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52605       };
52606     } catch (...) {
52607       {
52608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52609       };
52610     }
52611   }
52612 }
52613
52614
52615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
52616   unsigned int jresult ;
52617   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52618   bool result;
52619
52620   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52621   {
52622     try {
52623       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);
52624     } catch (std::out_of_range& e) {
52625       {
52626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52627       };
52628     } catch (std::exception& e) {
52629       {
52630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52631       };
52632     } catch (...) {
52633       {
52634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52635       };
52636     }
52637   }
52638   jresult = result;
52639   return jresult;
52640 }
52641
52642
52643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
52644   unsigned long jresult ;
52645   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52646   std::size_t result;
52647
52648   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52649   {
52650     try {
52651       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);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52659       };
52660     } catch (...) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52663       };
52664     }
52665   }
52666   jresult = (unsigned long)result;
52667   return jresult;
52668 }
52669
52670
52671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
52672   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52673   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52674
52675   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52676   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52677   {
52678     try {
52679       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
52680     } catch (std::out_of_range& e) {
52681       {
52682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52683       };
52684     } catch (std::exception& e) {
52685       {
52686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52691       };
52692     }
52693   }
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
52698   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52699   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
52700
52701   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52702   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
52703   {
52704     try {
52705       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
52706     } catch (std::out_of_range& e) {
52707       {
52708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (std::exception& e) {
52711       {
52712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (...) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52717       };
52718     }
52719   }
52720 }
52721
52722
52723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
52724   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52725   Dali::Actor arg2 ;
52726   bool arg3 ;
52727   Dali::DevelActor::VisibilityChange::Type arg4 ;
52728   Dali::Actor *argp2 ;
52729
52730   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52731   argp2 = (Dali::Actor *)jarg2;
52732   if (!argp2) {
52733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52734     return ;
52735   }
52736   arg2 = *argp2;
52737   arg3 = jarg3 ? true : false;
52738   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
52739   {
52740     try {
52741       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
52742     } catch (std::out_of_range& e) {
52743       {
52744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52745       };
52746     } catch (std::exception& e) {
52747       {
52748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52749       };
52750     } catch (...) {
52751       {
52752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52753       };
52754     }
52755   }
52756 }
52757
52758
52759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
52760   void * jresult ;
52761   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
52762
52763   {
52764     try {
52765       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (...) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52777       };
52778     }
52779   }
52780   jresult = (void *)result;
52781   return jresult;
52782 }
52783
52784
52785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
52786   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
52787
52788   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
52789   {
52790     try {
52791       delete arg1;
52792     } catch (std::out_of_range& e) {
52793       {
52794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52795       };
52796     } catch (std::exception& e) {
52797       {
52798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52799       };
52800     } catch (...) {
52801       {
52802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52803       };
52804     }
52805   }
52806 }
52807
52808
52809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52810   void * jresult ;
52811   Dali::Timer *result = 0 ;
52812
52813   {
52814     try {
52815       result = (Dali::Timer *)new Dali::Timer();
52816     } catch (std::out_of_range& e) {
52817       {
52818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52819       };
52820     } catch (std::exception& e) {
52821       {
52822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52823       };
52824     } catch (...) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52827       };
52828     }
52829   }
52830   jresult = (void *)result;
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52836   void * jresult ;
52837   unsigned int arg1 ;
52838   Dali::Timer result;
52839
52840   arg1 = (unsigned int)jarg1;
52841   {
52842     try {
52843       result = Dali::Timer::New(arg1);
52844     } catch (std::out_of_range& e) {
52845       {
52846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52847       };
52848     } catch (std::exception& e) {
52849       {
52850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52851       };
52852     } catch (...) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52855       };
52856     }
52857   }
52858   jresult = new Dali::Timer((const Dali::Timer &)result);
52859   return jresult;
52860 }
52861
52862
52863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52864   void * jresult ;
52865   Dali::Timer *arg1 = 0 ;
52866   Dali::Timer *result = 0 ;
52867
52868   arg1 = (Dali::Timer *)jarg1;
52869   if (!arg1) {
52870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52871     return 0;
52872   }
52873   {
52874     try {
52875       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52876     } catch (std::out_of_range& e) {
52877       {
52878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52879       };
52880     } catch (std::exception& e) {
52881       {
52882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52883       };
52884     } catch (...) {
52885       {
52886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52887       };
52888     }
52889   }
52890   jresult = (void *)result;
52891   return jresult;
52892 }
52893
52894
52895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52896   void * jresult ;
52897   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52898   Dali::Timer *arg2 = 0 ;
52899   Dali::Timer *result = 0 ;
52900
52901   arg1 = (Dali::Timer *)jarg1;
52902   arg2 = (Dali::Timer *)jarg2;
52903   if (!arg2) {
52904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52905     return 0;
52906   }
52907   {
52908     try {
52909       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52910     } catch (std::out_of_range& e) {
52911       {
52912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52913       };
52914     } catch (std::exception& e) {
52915       {
52916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52917       };
52918     } catch (...) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52921       };
52922     }
52923   }
52924   jresult = (void *)result;
52925   return jresult;
52926 }
52927
52928
52929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52930   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52931
52932   arg1 = (Dali::Timer *)jarg1;
52933   {
52934     try {
52935       delete arg1;
52936     } catch (std::out_of_range& e) {
52937       {
52938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52939       };
52940     } catch (std::exception& e) {
52941       {
52942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52943       };
52944     } catch (...) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52947       };
52948     }
52949   }
52950 }
52951
52952
52953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52954   void * jresult ;
52955   Dali::BaseHandle arg1 ;
52956   Dali::BaseHandle *argp1 ;
52957   Dali::Timer result;
52958
52959   argp1 = (Dali::BaseHandle *)jarg1;
52960   if (!argp1) {
52961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52962     return 0;
52963   }
52964   arg1 = *argp1;
52965   {
52966     try {
52967       result = Dali::Timer::DownCast(arg1);
52968     } catch (std::out_of_range& e) {
52969       {
52970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52971       };
52972     } catch (std::exception& e) {
52973       {
52974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52975       };
52976     } catch (...) {
52977       {
52978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52979       };
52980     }
52981   }
52982   jresult = new Dali::Timer((const Dali::Timer &)result);
52983   return jresult;
52984 }
52985
52986
52987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52988   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52989
52990   arg1 = (Dali::Timer *)jarg1;
52991   {
52992     try {
52993       (arg1)->Start();
52994     } catch (std::out_of_range& e) {
52995       {
52996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52997       };
52998     } catch (std::exception& e) {
52999       {
53000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53001       };
53002     } catch (...) {
53003       {
53004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53005       };
53006     }
53007   }
53008 }
53009
53010
53011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
53012   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53013
53014   arg1 = (Dali::Timer *)jarg1;
53015   {
53016     try {
53017       (arg1)->Stop();
53018     } catch (std::out_of_range& e) {
53019       {
53020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53021       };
53022     } catch (std::exception& e) {
53023       {
53024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53025       };
53026     } catch (...) {
53027       {
53028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53029       };
53030     }
53031   }
53032 }
53033
53034
53035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
53036   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53037   unsigned int arg2 ;
53038
53039   arg1 = (Dali::Timer *)jarg1;
53040   arg2 = (unsigned int)jarg2;
53041   {
53042     try {
53043       (arg1)->SetInterval(arg2);
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53051       };
53052     } catch (...) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53055       };
53056     }
53057   }
53058 }
53059
53060
53061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
53062   unsigned int jresult ;
53063   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53064   unsigned int result;
53065
53066   arg1 = (Dali::Timer *)jarg1;
53067   {
53068     try {
53069       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
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 = result;
53085   return jresult;
53086 }
53087
53088
53089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
53090   unsigned int jresult ;
53091   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53092   bool result;
53093
53094   arg1 = (Dali::Timer *)jarg1;
53095   {
53096     try {
53097       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53109       };
53110     }
53111   }
53112   jresult = result;
53113   return jresult;
53114 }
53115
53116
53117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
53118   void * jresult ;
53119   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
53120   Dali::Timer::TimerSignalType *result = 0 ;
53121
53122   arg1 = (Dali::Timer *)jarg1;
53123   {
53124     try {
53125       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
53126     } catch (std::out_of_range& e) {
53127       {
53128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53129       };
53130     } catch (std::exception& e) {
53131       {
53132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (...) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53137       };
53138     }
53139   }
53140   jresult = (void *)result;
53141   return jresult;
53142 }
53143
53144
53145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
53146   void * jresult ;
53147   Dali::DragAndDropDetector *result = 0 ;
53148
53149   {
53150     try {
53151       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53159       };
53160     } catch (...) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53163       };
53164     }
53165   }
53166   jresult = (void *)result;
53167   return jresult;
53168 }
53169
53170
53171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
53172   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53173
53174   arg1 = (Dali::DragAndDropDetector *)jarg1;
53175   {
53176     try {
53177       delete arg1;
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53185       };
53186     } catch (...) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53189       };
53190     }
53191   }
53192 }
53193
53194
53195 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
53196   char * jresult ;
53197   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53198   std::string *result = 0 ;
53199
53200   arg1 = (Dali::DragAndDropDetector *)jarg1;
53201   {
53202     try {
53203       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
53204     } catch (std::out_of_range& e) {
53205       {
53206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (std::exception& e) {
53209       {
53210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53211       };
53212     } catch (...) {
53213       {
53214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53215       };
53216     }
53217   }
53218   jresult = SWIG_csharp_string_callback(result->c_str());
53219   return jresult;
53220 }
53221
53222
53223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53224   void * jresult ;
53225   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53226   Dali::Vector2 result;
53227
53228   arg1 = (Dali::DragAndDropDetector *)jarg1;
53229   {
53230     try {
53231       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53232     } catch (std::out_of_range& e) {
53233       {
53234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53235       };
53236     } catch (std::exception& e) {
53237       {
53238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53239       };
53240     } catch (...) {
53241       {
53242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53243       };
53244     }
53245   }
53246   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53247   return jresult;
53248 }
53249
53250
53251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53252   void * jresult ;
53253   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53254   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53255
53256   arg1 = (Dali::DragAndDropDetector *)jarg1;
53257   {
53258     try {
53259       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53260     } catch (std::out_of_range& e) {
53261       {
53262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53263       };
53264     } catch (std::exception& e) {
53265       {
53266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53267       };
53268     } catch (...) {
53269       {
53270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53271       };
53272     }
53273   }
53274   jresult = (void *)result;
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53280   void * jresult ;
53281   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53282   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53283
53284   arg1 = (Dali::DragAndDropDetector *)jarg1;
53285   {
53286     try {
53287       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53288     } catch (std::out_of_range& e) {
53289       {
53290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53291       };
53292     } catch (std::exception& e) {
53293       {
53294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53295       };
53296     } catch (...) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53299       };
53300     }
53301   }
53302   jresult = (void *)result;
53303   return jresult;
53304 }
53305
53306
53307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53308   void * jresult ;
53309   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53310   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53311
53312   arg1 = (Dali::DragAndDropDetector *)jarg1;
53313   {
53314     try {
53315       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53316     } catch (std::out_of_range& e) {
53317       {
53318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53319       };
53320     } catch (std::exception& e) {
53321       {
53322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53323       };
53324     } catch (...) {
53325       {
53326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53327       };
53328     }
53329   }
53330   jresult = (void *)result;
53331   return jresult;
53332 }
53333
53334
53335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53336   void * jresult ;
53337   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53338   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53339
53340   arg1 = (Dali::DragAndDropDetector *)jarg1;
53341   {
53342     try {
53343       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53344     } catch (std::out_of_range& e) {
53345       {
53346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53347       };
53348     } catch (std::exception& e) {
53349       {
53350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53351       };
53352     } catch (...) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53355       };
53356     }
53357   }
53358   jresult = (void *)result;
53359   return jresult;
53360 }
53361
53362
53363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53364   void * jresult ;
53365   Dali::ApplicationExtensions *result = 0 ;
53366
53367   {
53368     try {
53369       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53370     } catch (std::out_of_range& e) {
53371       {
53372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53373       };
53374     } catch (std::exception& e) {
53375       {
53376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53377       };
53378     } catch (...) {
53379       {
53380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53381       };
53382     }
53383   }
53384   jresult = (void *)result;
53385   return jresult;
53386 }
53387
53388
53389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53390   void * jresult ;
53391   Dali::Application *arg1 = (Dali::Application *) 0 ;
53392   Dali::ApplicationExtensions *result = 0 ;
53393
53394   arg1 = (Dali::Application *)jarg1;
53395   {
53396     try {
53397       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53398     } catch (std::out_of_range& e) {
53399       {
53400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53401       };
53402     } catch (std::exception& e) {
53403       {
53404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53409       };
53410     }
53411   }
53412   jresult = (void *)result;
53413   return jresult;
53414 }
53415
53416
53417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53418   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53419
53420   arg1 = (Dali::ApplicationExtensions *)jarg1;
53421   {
53422     try {
53423       delete arg1;
53424     } catch (std::out_of_range& e) {
53425       {
53426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53427       };
53428     } catch (std::exception& e) {
53429       {
53430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53431       };
53432     } catch (...) {
53433       {
53434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53435       };
53436     }
53437   }
53438 }
53439
53440
53441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53442   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53443
53444   arg1 = (Dali::ApplicationExtensions *)jarg1;
53445   {
53446     try {
53447       (arg1)->Init();
53448     } catch (std::out_of_range& e) {
53449       {
53450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53451       };
53452     } catch (std::exception& e) {
53453       {
53454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53455       };
53456     } catch (...) {
53457       {
53458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53459       };
53460     }
53461   }
53462 }
53463
53464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
53465   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53466
53467   arg1 = (Dali::ApplicationExtensions *)jarg1;
53468   {
53469     try {
53470       (arg1)->Start();
53471     } catch (std::out_of_range& e) {
53472       {
53473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53474       };
53475     } catch (std::exception& e) {
53476       {
53477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53478       };
53479     } catch (...) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53482       };
53483     }
53484   }
53485 }
53486
53487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53488   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53489
53490   arg1 = (Dali::ApplicationExtensions *)jarg1;
53491   {
53492     try {
53493       (arg1)->Terminate();
53494     } catch (std::out_of_range& e) {
53495       {
53496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53497       };
53498     } catch (std::exception& e) {
53499       {
53500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53501       };
53502     } catch (...) {
53503       {
53504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53505       };
53506     }
53507   }
53508 }
53509
53510
53511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53512   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53513
53514   arg1 = (Dali::ApplicationExtensions *)jarg1;
53515   {
53516     try {
53517       (arg1)->Pause();
53518     } catch (std::out_of_range& e) {
53519       {
53520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53521       };
53522     } catch (std::exception& e) {
53523       {
53524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53525       };
53526     } catch (...) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53529       };
53530     }
53531   }
53532 }
53533
53534
53535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53536   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53537
53538   arg1 = (Dali::ApplicationExtensions *)jarg1;
53539   {
53540     try {
53541       (arg1)->Resume();
53542     } catch (std::out_of_range& e) {
53543       {
53544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53545       };
53546     } catch (std::exception& e) {
53547       {
53548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53549       };
53550     } catch (...) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53553       };
53554     }
53555   }
53556 }
53557
53558
53559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53560   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53561
53562   arg1 = (Dali::ApplicationExtensions *)jarg1;
53563   {
53564     try {
53565       (arg1)->LanguageChange();
53566     } catch (std::out_of_range& e) {
53567       {
53568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53569       };
53570     } catch (std::exception& e) {
53571       {
53572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53573       };
53574     } catch (...) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53577       };
53578     }
53579   }
53580 }
53581
53582
53583
53584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
53585   unsigned int jresult ;
53586   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53587   bool result;
53588
53589   arg1 = (Dali::Signal< bool () > *)jarg1;
53590   {
53591     try {
53592       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
53593     } catch (std::out_of_range& e) {
53594       {
53595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53596       };
53597     } catch (std::exception& e) {
53598       {
53599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53600       };
53601     } catch (...) {
53602       {
53603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53604       };
53605     }
53606   }
53607   jresult = result;
53608   return jresult;
53609 }
53610
53611
53612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
53613   unsigned long jresult ;
53614   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53615   std::size_t result;
53616
53617   arg1 = (Dali::Signal< bool () > *)jarg1;
53618   {
53619     try {
53620       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
53621     } catch (std::out_of_range& e) {
53622       {
53623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (std::exception& e) {
53626       {
53627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (...) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53632       };
53633     }
53634   }
53635   jresult = (unsigned long)result;
53636   return jresult;
53637 }
53638
53639
53640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
53641   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53642   bool (*arg2)() = (bool (*)()) 0 ;
53643
53644   arg1 = (Dali::Signal< bool () > *)jarg1;
53645   arg2 = (bool (*)())jarg2;
53646   {
53647     try {
53648       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
53649     } catch (std::out_of_range& e) {
53650       {
53651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (std::exception& e) {
53654       {
53655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663 }
53664
53665
53666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
53667   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53668   bool (*arg2)() = (bool (*)()) 0 ;
53669
53670   arg1 = (Dali::Signal< bool () > *)jarg1;
53671   arg2 = (bool (*)())jarg2;
53672   {
53673     try {
53674       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
53675     } catch (std::out_of_range& e) {
53676       {
53677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53678       };
53679     } catch (std::exception& e) {
53680       {
53681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53682       };
53683     } catch (...) {
53684       {
53685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53686       };
53687     }
53688   }
53689 }
53690
53691
53692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
53693   unsigned int jresult ;
53694   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53695   bool result;
53696
53697   arg1 = (Dali::Signal< bool () > *)jarg1;
53698   {
53699     try {
53700       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
53701     } catch (std::out_of_range& e) {
53702       {
53703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53704       };
53705     } catch (std::exception& e) {
53706       {
53707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53708       };
53709     } catch (...) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53712       };
53713     }
53714   }
53715   jresult = result;
53716   return jresult;
53717 }
53718
53719
53720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
53721   void * jresult ;
53722   Dali::Signal< bool () > *result = 0 ;
53723
53724   {
53725     try {
53726       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
53727     } catch (std::out_of_range& e) {
53728       {
53729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53730       };
53731     } catch (std::exception& e) {
53732       {
53733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53734       };
53735     } catch (...) {
53736       {
53737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53738       };
53739     }
53740   }
53741   jresult = (void *)result;
53742   return jresult;
53743 }
53744
53745
53746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
53747   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
53748
53749   arg1 = (Dali::Signal< bool () > *)jarg1;
53750   {
53751     try {
53752       delete arg1;
53753     } catch (std::out_of_range& e) {
53754       {
53755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53756       };
53757     } catch (std::exception& e) {
53758       {
53759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53760       };
53761     } catch (...) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53764       };
53765     }
53766   }
53767 }
53768
53769
53770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
53771   int jresult ;
53772   int result;
53773
53774   {
53775     try {
53776       result = (int)Dali::Toolkit::Visual::Property::TYPE;
53777     } catch (std::out_of_range& e) {
53778       {
53779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53780       };
53781     } catch (std::exception& e) {
53782       {
53783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (...) {
53786       {
53787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53788       };
53789     }
53790   }
53791   jresult = (int)result;
53792   return jresult;
53793 }
53794
53795
53796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
53797   int jresult ;
53798   int result;
53799
53800   {
53801     try {
53802       result = (int)Dali::Toolkit::Visual::Property::SHADER;
53803     } catch (std::out_of_range& e) {
53804       {
53805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53806       };
53807     } catch (std::exception& e) {
53808       {
53809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53810       };
53811     } catch (...) {
53812       {
53813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53814       };
53815     }
53816   }
53817   jresult = (int)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
53823   int jresult ;
53824   int result;
53825
53826   {
53827     try {
53828       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
53829     } catch (std::out_of_range& e) {
53830       {
53831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53832       };
53833     } catch (std::exception& e) {
53834       {
53835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53836       };
53837     } catch (...) {
53838       {
53839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53840       };
53841     }
53842   }
53843   jresult = (int)result;
53844   return jresult;
53845 }
53846
53847
53848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
53849   int jresult ;
53850   int result;
53851
53852   {
53853     try {
53854       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
53855     } catch (std::out_of_range& e) {
53856       {
53857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53858       };
53859     } catch (std::exception& e) {
53860       {
53861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53862       };
53863     } catch (...) {
53864       {
53865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53866       };
53867     }
53868   }
53869   jresult = (int)result;
53870   return jresult;
53871 }
53872
53873
53874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
53875   int jresult ;
53876   int result;
53877
53878   {
53879     try {
53880       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
53881     } catch (std::out_of_range& e) {
53882       {
53883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (std::exception& e) {
53886       {
53887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53892       };
53893     }
53894   }
53895   jresult = (int)result;
53896   return jresult;
53897 }
53898
53899
53900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
53901   int jresult ;
53902   int result;
53903
53904   {
53905     try {
53906       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
53907     } catch (std::out_of_range& e) {
53908       {
53909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53910       };
53911     } catch (std::exception& e) {
53912       {
53913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53914       };
53915     } catch (...) {
53916       {
53917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53918       };
53919     }
53920   }
53921   jresult = (int)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
53927   int jresult ;
53928   int result;
53929
53930   {
53931     try {
53932       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53944       };
53945     }
53946   }
53947   jresult = (int)result;
53948   return jresult;
53949 }
53950
53951
53952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
53953   int jresult ;
53954   int result;
53955
53956   {
53957     try {
53958       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
53959     } catch (std::out_of_range& e) {
53960       {
53961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53962       };
53963     } catch (std::exception& e) {
53964       {
53965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53966       };
53967     } catch (...) {
53968       {
53969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53970       };
53971     }
53972   }
53973   jresult = (int)result;
53974   return jresult;
53975 }
53976
53977
53978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
53979   int jresult ;
53980   int result;
53981
53982   {
53983     try {
53984       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
53985     } catch (std::out_of_range& e) {
53986       {
53987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53988       };
53989     } catch (std::exception& e) {
53990       {
53991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53992       };
53993     } catch (...) {
53994       {
53995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53996       };
53997     }
53998   }
53999   jresult = (int)result;
54000   return jresult;
54001 }
54002
54003
54004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
54005   int jresult ;
54006   int result;
54007
54008   {
54009     try {
54010       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
54011     } catch (std::out_of_range& e) {
54012       {
54013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54014       };
54015     } catch (std::exception& e) {
54016       {
54017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54018       };
54019     } catch (...) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54022       };
54023     }
54024   }
54025   jresult = (int)result;
54026   return jresult;
54027 }
54028
54029
54030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
54031   int jresult ;
54032   int result;
54033
54034   {
54035     try {
54036       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
54037     } catch (std::out_of_range& e) {
54038       {
54039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54040       };
54041     } catch (std::exception& e) {
54042       {
54043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54044       };
54045     } catch (...) {
54046       {
54047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54048       };
54049     }
54050   }
54051   jresult = (int)result;
54052   return jresult;
54053 }
54054
54055
54056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
54057   int jresult ;
54058   int result;
54059
54060   {
54061     try {
54062       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
54063     } catch (std::out_of_range& e) {
54064       {
54065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54066       };
54067     } catch (std::exception& e) {
54068       {
54069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (...) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54074       };
54075     }
54076   }
54077   jresult = (int)result;
54078   return jresult;
54079 }
54080
54081
54082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
54083   int jresult ;
54084   int result;
54085
54086   {
54087     try {
54088       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
54089     } catch (std::out_of_range& e) {
54090       {
54091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54092       };
54093     } catch (std::exception& e) {
54094       {
54095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54096       };
54097     } catch (...) {
54098       {
54099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54100       };
54101     }
54102   }
54103   jresult = (int)result;
54104   return jresult;
54105 }
54106
54107
54108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
54109   int jresult ;
54110   int result;
54111
54112   {
54113     try {
54114       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54122       };
54123     } catch (...) {
54124       {
54125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54126       };
54127     }
54128   }
54129   jresult = (int)result;
54130   return jresult;
54131 }
54132
54133
54134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
54135   int jresult ;
54136   int result;
54137
54138   {
54139     try {
54140       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
54141     } catch (std::out_of_range& e) {
54142       {
54143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54144       };
54145     } catch (std::exception& e) {
54146       {
54147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54148       };
54149     } catch (...) {
54150       {
54151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54152       };
54153     }
54154   }
54155   jresult = (int)result;
54156   return jresult;
54157 }
54158
54159
54160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
54161   int jresult ;
54162   int result;
54163
54164   {
54165     try {
54166       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
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 = (int)result;
54182   return jresult;
54183 }
54184
54185
54186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
54187   int jresult ;
54188   int result;
54189
54190   {
54191     try {
54192       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54200       };
54201     } catch (...) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54204       };
54205     }
54206   }
54207   jresult = (int)result;
54208   return jresult;
54209 }
54210
54211
54212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
54213   int jresult ;
54214   int result;
54215
54216   {
54217     try {
54218       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
54219     } catch (std::out_of_range& e) {
54220       {
54221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54222       };
54223     } catch (std::exception& e) {
54224       {
54225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54226       };
54227     } catch (...) {
54228       {
54229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54230       };
54231     }
54232   }
54233   jresult = (int)result;
54234   return jresult;
54235 }
54236
54237
54238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
54239   int jresult ;
54240   int result;
54241
54242   {
54243     try {
54244       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (...) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54256       };
54257     }
54258   }
54259   jresult = (int)result;
54260   return jresult;
54261 }
54262
54263
54264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
54265   int jresult ;
54266   int result;
54267
54268   {
54269     try {
54270       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54282       };
54283     }
54284   }
54285   jresult = (int)result;
54286   return jresult;
54287 }
54288
54289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
54290   int jresult ;
54291   int result;
54292
54293   {
54294     try {
54295       result = (int)Dali::Toolkit::DevelImageVisual::Property::ALPHA_MASK_URL;
54296     } catch (std::out_of_range& e) {
54297       {
54298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54299       };
54300     } catch (std::exception& e) {
54301       {
54302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54303       };
54304     } catch (...) {
54305       {
54306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54307       };
54308     }
54309   }
54310   jresult = (int)result;
54311   return jresult;
54312 }
54313
54314
54315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
54316   int jresult ;
54317   int result;
54318   {
54319     try
54320     {
54321       result = (int)Dali::Toolkit::DevelImageVisual::Property::BATCH_SIZE;
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54329       };
54330     } catch (...) {
54331       {
54332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54333       };
54334     }
54335   }
54336   jresult = (int)result;
54337   return jresult;
54338 }
54339
54340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
54341   int jresult ;
54342   int result;
54343   {
54344     try
54345     {
54346       result = (int)Dali::Toolkit::DevelImageVisual::Property::CACHE_SIZE;
54347     } catch (std::out_of_range& e) {
54348       {
54349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54350       };
54351     } catch (std::exception& e) {
54352       {
54353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54354       };
54355     } catch (...) {
54356       {
54357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54358       };
54359     }
54360   }
54361   jresult = (int)result;
54362   return jresult;
54363 }
54364
54365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
54366   int jresult ;
54367   int result;
54368   {
54369     try
54370     {
54371       result = (int)Dali::Toolkit::DevelImageVisual::Property::FRAME_DELAY;
54372     } catch (std::out_of_range& e) {
54373       {
54374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54375       };
54376     } catch (std::exception& e) {
54377       {
54378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54379       };
54380     } catch (...) {
54381       {
54382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54383       };
54384     }
54385   }
54386   jresult = (int)result;
54387   return jresult;
54388 }
54389
54390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
54391   int jresult ;
54392   int result;
54393   {
54394     try
54395     {
54396       result = (int)Dali::Toolkit::DevelImageVisual::Property::MASK_CONTENT_SCALE;
54397     } catch (std::out_of_range& e) {
54398       {
54399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54400       };
54401     } catch (std::exception& e) {
54402       {
54403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54404       };
54405     } catch (...) {
54406       {
54407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54408       };
54409     }
54410   }
54411   jresult = (int)result;
54412   return jresult;
54413 }
54414
54415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
54416   int jresult ;
54417   int result;
54418   {
54419     try
54420     {
54421       result = (int)Dali::Toolkit::DevelImageVisual::Property::CROP_TO_MASK;
54422     } catch (std::out_of_range& e) {
54423       {
54424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54425       };
54426     } catch (std::exception& e) {
54427       {
54428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54429       };
54430     } catch (...) {
54431       {
54432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54433       };
54434     }
54435   }
54436   jresult = (int)result;
54437   return jresult;
54438 }
54439
54440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
54441   int jresult ;
54442   int result;
54443
54444   {
54445     try {
54446       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
54447     } catch (std::out_of_range& e) {
54448       {
54449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54450       };
54451     } catch (std::exception& e) {
54452       {
54453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54454       };
54455     } catch (...) {
54456       {
54457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54458       };
54459     }
54460   }
54461   jresult = (int)result;
54462   return jresult;
54463 }
54464
54465
54466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
54467   int jresult ;
54468   int result;
54469
54470   {
54471     try {
54472       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54484       };
54485     }
54486   }
54487   jresult = (int)result;
54488   return jresult;
54489 }
54490
54491
54492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
54493   int jresult ;
54494   int result;
54495
54496   {
54497     try {
54498       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
54499     } catch (std::out_of_range& e) {
54500       {
54501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54502       };
54503     } catch (std::exception& e) {
54504       {
54505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54506       };
54507     } catch (...) {
54508       {
54509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54510       };
54511     }
54512   }
54513   jresult = (int)result;
54514   return jresult;
54515 }
54516
54517
54518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
54519   int jresult ;
54520   int result;
54521
54522   {
54523     try {
54524       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
54525     } catch (std::out_of_range& e) {
54526       {
54527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54528       };
54529     } catch (std::exception& e) {
54530       {
54531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54532       };
54533     } catch (...) {
54534       {
54535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54536       };
54537     }
54538   }
54539   jresult = (int)result;
54540   return jresult;
54541 }
54542
54543
54544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
54545   int jresult ;
54546   int result;
54547
54548   {
54549     try {
54550       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
54551     } catch (std::out_of_range& e) {
54552       {
54553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54554       };
54555     } catch (std::exception& e) {
54556       {
54557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54558       };
54559     } catch (...) {
54560       {
54561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54562       };
54563     }
54564   }
54565   jresult = (int)result;
54566   return jresult;
54567 }
54568
54569
54570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
54571   int jresult ;
54572   int result;
54573
54574   {
54575     try {
54576       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
54577     } catch (std::out_of_range& e) {
54578       {
54579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54580       };
54581     } catch (std::exception& e) {
54582       {
54583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54584       };
54585     } catch (...) {
54586       {
54587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54588       };
54589     }
54590   }
54591   jresult = (int)result;
54592   return jresult;
54593 }
54594
54595
54596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
54597   int jresult ;
54598   int result;
54599
54600   {
54601     try {
54602       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
54603     } catch (std::out_of_range& e) {
54604       {
54605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54606       };
54607     } catch (std::exception& e) {
54608       {
54609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54610       };
54611     } catch (...) {
54612       {
54613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54614       };
54615     }
54616   }
54617   jresult = (int)result;
54618   return jresult;
54619 }
54620
54621
54622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
54623   int jresult ;
54624   int result;
54625
54626   {
54627     try {
54628       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
54629     } catch (std::out_of_range& e) {
54630       {
54631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54632       };
54633     } catch (std::exception& e) {
54634       {
54635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54636       };
54637     } catch (...) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54640       };
54641     }
54642   }
54643   jresult = (int)result;
54644   return jresult;
54645 }
54646
54647
54648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
54649   int jresult ;
54650   int result;
54651
54652   {
54653     try {
54654       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
54655     } catch (std::out_of_range& e) {
54656       {
54657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54658       };
54659     } catch (std::exception& e) {
54660       {
54661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54662       };
54663     } catch (...) {
54664       {
54665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54666       };
54667     }
54668   }
54669   jresult = (int)result;
54670   return jresult;
54671 }
54672
54673
54674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
54675   int jresult ;
54676   int result;
54677
54678   {
54679     try {
54680       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
54681     } catch (std::out_of_range& e) {
54682       {
54683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54684       };
54685     } catch (std::exception& e) {
54686       {
54687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54688       };
54689     } catch (...) {
54690       {
54691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54692       };
54693     }
54694   }
54695   jresult = (int)result;
54696   return jresult;
54697 }
54698
54699
54700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
54701   int jresult ;
54702   int result;
54703
54704   {
54705     try {
54706       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
54707     } catch (std::out_of_range& e) {
54708       {
54709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54710       };
54711     } catch (std::exception& e) {
54712       {
54713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54714       };
54715     } catch (...) {
54716       {
54717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54718       };
54719     }
54720   }
54721   jresult = (int)result;
54722   return jresult;
54723 }
54724
54725
54726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
54727   int jresult ;
54728   int result;
54729
54730   {
54731     try {
54732       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
54733     } catch (std::out_of_range& e) {
54734       {
54735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54736       };
54737     } catch (std::exception& e) {
54738       {
54739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54740       };
54741     } catch (...) {
54742       {
54743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54744       };
54745     }
54746   }
54747   jresult = (int)result;
54748   return jresult;
54749 }
54750
54751
54752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
54753   int jresult ;
54754   int result;
54755
54756   {
54757     try {
54758       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
54759     } catch (std::out_of_range& e) {
54760       {
54761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (std::exception& e) {
54764       {
54765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54766       };
54767     } catch (...) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54770       };
54771     }
54772   }
54773   jresult = (int)result;
54774   return jresult;
54775 }
54776
54777
54778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
54779   int jresult ;
54780   int result;
54781
54782   {
54783     try {
54784       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (...) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54796       };
54797     }
54798   }
54799   jresult = (int)result;
54800   return jresult;
54801 }
54802
54803
54804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
54805   int jresult ;
54806   int result;
54807
54808   {
54809     try {
54810       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
54811     } catch (std::out_of_range& e) {
54812       {
54813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54814       };
54815     } catch (std::exception& e) {
54816       {
54817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54818       };
54819     } catch (...) {
54820       {
54821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54822       };
54823     }
54824   }
54825   jresult = (int)result;
54826   return jresult;
54827 }
54828
54829
54830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
54831   int jresult ;
54832   int result;
54833
54834   {
54835     try {
54836       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
54837     } catch (std::out_of_range& e) {
54838       {
54839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54840       };
54841     } catch (std::exception& e) {
54842       {
54843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (...) {
54846       {
54847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54848       };
54849     }
54850   }
54851   jresult = (int)result;
54852   return jresult;
54853 }
54854
54855
54856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
54857   int jresult ;
54858   int result;
54859
54860   {
54861     try {
54862       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
54863     } catch (std::out_of_range& e) {
54864       {
54865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54866       };
54867     } catch (std::exception& e) {
54868       {
54869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54870       };
54871     } catch (...) {
54872       {
54873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54874       };
54875     }
54876   }
54877   jresult = (int)result;
54878   return jresult;
54879 }
54880
54881
54882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
54883   int jresult ;
54884   int result;
54885
54886   {
54887     try {
54888       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
54889     } catch (std::out_of_range& e) {
54890       {
54891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54892       };
54893     } catch (std::exception& e) {
54894       {
54895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54896       };
54897     } catch (...) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54900       };
54901     }
54902   }
54903   jresult = (int)result;
54904   return jresult;
54905 }
54906
54907
54908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
54909   int jresult ;
54910   int result;
54911
54912   {
54913     try {
54914       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
54915     } catch (std::out_of_range& e) {
54916       {
54917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54918       };
54919     } catch (std::exception& e) {
54920       {
54921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54922       };
54923     } catch (...) {
54924       {
54925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54926       };
54927     }
54928   }
54929   jresult = (int)result;
54930   return jresult;
54931 }
54932
54933
54934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
54935   int jresult ;
54936   int result;
54937
54938   {
54939     try {
54940       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
54941     } catch (std::out_of_range& e) {
54942       {
54943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54944       };
54945     } catch (std::exception& e) {
54946       {
54947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54948       };
54949     } catch (...) {
54950       {
54951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54952       };
54953     }
54954   }
54955   jresult = (int)result;
54956   return jresult;
54957 }
54958
54959
54960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
54961   int jresult ;
54962   int result;
54963
54964   {
54965     try {
54966       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
54967     } catch (std::out_of_range& e) {
54968       {
54969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (std::exception& e) {
54972       {
54973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981   jresult = (int)result;
54982   return jresult;
54983 }
54984
54985
54986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
54987   int jresult ;
54988   int result;
54989
54990   {
54991     try {
54992       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
54993     } catch (std::out_of_range& e) {
54994       {
54995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54996       };
54997     } catch (std::exception& e) {
54998       {
54999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55000       };
55001     } catch (...) {
55002       {
55003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55004       };
55005     }
55006   }
55007   jresult = (int)result;
55008   return jresult;
55009 }
55010
55011
55012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
55013   int jresult ;
55014   int result;
55015
55016   {
55017     try {
55018       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
55019     } catch (std::out_of_range& e) {
55020       {
55021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55022       };
55023     } catch (std::exception& e) {
55024       {
55025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55026       };
55027     } catch (...) {
55028       {
55029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55030       };
55031     }
55032   }
55033   jresult = (int)result;
55034   return jresult;
55035 }
55036
55037
55038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
55039   int jresult ;
55040   int result;
55041
55042   {
55043     try {
55044       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
55045     } catch (std::out_of_range& e) {
55046       {
55047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55048       };
55049     } catch (std::exception& e) {
55050       {
55051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55052       };
55053     } catch (...) {
55054       {
55055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55056       };
55057     }
55058   }
55059   jresult = (int)result;
55060   return jresult;
55061 }
55062
55063
55064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
55065   int jresult ;
55066   int result;
55067
55068   {
55069     try {
55070       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
55071     } catch (std::out_of_range& e) {
55072       {
55073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55074       };
55075     } catch (std::exception& e) {
55076       {
55077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55078       };
55079     } catch (...) {
55080       {
55081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55082       };
55083     }
55084   }
55085   jresult = (int)result;
55086   return jresult;
55087 }
55088
55089
55090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
55091   int jresult ;
55092   int result;
55093
55094   {
55095     try {
55096       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
55097     } catch (std::out_of_range& e) {
55098       {
55099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55100       };
55101     } catch (std::exception& e) {
55102       {
55103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55104       };
55105     } catch (...) {
55106       {
55107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55108       };
55109     }
55110   }
55111   jresult = (int)result;
55112   return jresult;
55113 }
55114
55115
55116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
55117   int jresult ;
55118   int result;
55119
55120   {
55121     try {
55122       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
55123     } catch (std::out_of_range& e) {
55124       {
55125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55126       };
55127     } catch (std::exception& e) {
55128       {
55129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55130       };
55131     } catch (...) {
55132       {
55133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55134       };
55135     }
55136   }
55137   jresult = (int)result;
55138   return jresult;
55139 }
55140
55141
55142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
55143   int jresult ;
55144   int result;
55145
55146   {
55147     try {
55148       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
55149     } catch (std::out_of_range& e) {
55150       {
55151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55152       };
55153     } catch (std::exception& e) {
55154       {
55155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55156       };
55157     } catch (...) {
55158       {
55159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55160       };
55161     }
55162   }
55163   jresult = (int)result;
55164   return jresult;
55165 }
55166
55167
55168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
55169   int jresult ;
55170   int result;
55171
55172   {
55173     try {
55174       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
55175     } catch (std::out_of_range& e) {
55176       {
55177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55178       };
55179     } catch (std::exception& e) {
55180       {
55181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55182       };
55183     } catch (...) {
55184       {
55185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55186       };
55187     }
55188   }
55189   jresult = (int)result;
55190   return jresult;
55191 }
55192
55193
55194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
55195   int jresult ;
55196   int result;
55197
55198   {
55199     try {
55200       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
55201     } catch (std::out_of_range& e) {
55202       {
55203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55204       };
55205     } catch (std::exception& e) {
55206       {
55207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55208       };
55209     } catch (...) {
55210       {
55211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55212       };
55213     }
55214   }
55215   jresult = (int)result;
55216   return jresult;
55217 }
55218
55219
55220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
55221   int jresult ;
55222   int result;
55223
55224   {
55225     try {
55226       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55238       };
55239     }
55240   }
55241   jresult = (int)result;
55242   return jresult;
55243 }
55244
55245
55246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
55247   int jresult ;
55248   int result;
55249
55250   {
55251     try {
55252       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
55253     } catch (std::out_of_range& e) {
55254       {
55255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55256       };
55257     } catch (std::exception& e) {
55258       {
55259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55260       };
55261     } catch (...) {
55262       {
55263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55264       };
55265     }
55266   }
55267   jresult = (int)result;
55268   return jresult;
55269 }
55270
55271
55272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
55273   int jresult ;
55274   int result;
55275
55276   {
55277     try {
55278       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
55279     } catch (std::out_of_range& e) {
55280       {
55281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55282       };
55283     } catch (std::exception& e) {
55284       {
55285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55290       };
55291     }
55292   }
55293   jresult = (int)result;
55294   return jresult;
55295 }
55296
55297
55298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
55299   int jresult ;
55300   int result;
55301
55302   {
55303     try {
55304       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
55305     } catch (std::out_of_range& e) {
55306       {
55307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55308       };
55309     } catch (std::exception& e) {
55310       {
55311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55312       };
55313     } catch (...) {
55314       {
55315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55316       };
55317     }
55318   }
55319   jresult = (int)result;
55320   return jresult;
55321 }
55322
55323
55324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
55325   int jresult ;
55326   int result;
55327
55328   {
55329     try {
55330       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
55331     } catch (std::out_of_range& e) {
55332       {
55333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55334       };
55335     } catch (std::exception& e) {
55336       {
55337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55338       };
55339     } catch (...) {
55340       {
55341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55342       };
55343     }
55344   }
55345   jresult = (int)result;
55346   return jresult;
55347 }
55348
55349
55350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
55351   int jresult ;
55352   int result;
55353
55354   {
55355     try {
55356       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
55357     } catch (std::out_of_range& e) {
55358       {
55359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55360       };
55361     } catch (std::exception& e) {
55362       {
55363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55364       };
55365     } catch (...) {
55366       {
55367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55368       };
55369     }
55370   }
55371   jresult = (int)result;
55372   return jresult;
55373 }
55374
55375
55376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
55377   int jresult ;
55378   int result;
55379
55380   {
55381     try {
55382       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
55383     } catch (std::out_of_range& e) {
55384       {
55385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55386       };
55387     } catch (std::exception& e) {
55388       {
55389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (...) {
55392       {
55393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55394       };
55395     }
55396   }
55397   jresult = (int)result;
55398   return jresult;
55399 }
55400
55401
55402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
55403   void * jresult ;
55404   Dali::Toolkit::Builder *result = 0 ;
55405
55406   {
55407     try {
55408       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
55409     } catch (std::out_of_range& e) {
55410       {
55411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55412       };
55413     } catch (std::exception& e) {
55414       {
55415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (...) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55420       };
55421     }
55422   }
55423   jresult = (void *)result;
55424   return jresult;
55425 }
55426
55427
55428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
55429   void * jresult ;
55430   Dali::Toolkit::Builder result;
55431
55432   {
55433     try {
55434       result = Dali::Toolkit::Builder::New();
55435     } catch (std::out_of_range& e) {
55436       {
55437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55438       };
55439     } catch (std::exception& e) {
55440       {
55441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55442       };
55443     } catch (...) {
55444       {
55445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55446       };
55447     }
55448   }
55449   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
55450   return jresult;
55451 }
55452
55453
55454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
55455   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55456
55457   arg1 = (Dali::Toolkit::Builder *)jarg1;
55458   {
55459     try {
55460       delete arg1;
55461     } catch (std::out_of_range& e) {
55462       {
55463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55464       };
55465     } catch (std::exception& e) {
55466       {
55467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55468       };
55469     } catch (...) {
55470       {
55471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55472       };
55473     }
55474   }
55475 }
55476
55477
55478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
55479   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55480   std::string *arg2 = 0 ;
55481   Dali::Toolkit::Builder::UIFormat arg3 ;
55482
55483   arg1 = (Dali::Toolkit::Builder *)jarg1;
55484   if (!jarg2) {
55485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55486     return ;
55487   }
55488   std::string arg2_str(jarg2);
55489   arg2 = &arg2_str;
55490   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
55491   {
55492     try {
55493       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
55494     } catch (std::out_of_range& e) {
55495       {
55496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55497       };
55498     } catch (std::exception& e) {
55499       {
55500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55505       };
55506     }
55507   }
55508
55509   //argout typemap for const std::string&
55510
55511 }
55512
55513
55514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
55515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55516   std::string *arg2 = 0 ;
55517
55518   arg1 = (Dali::Toolkit::Builder *)jarg1;
55519   if (!jarg2) {
55520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55521     return ;
55522   }
55523   std::string arg2_str(jarg2);
55524   arg2 = &arg2_str;
55525   {
55526     try {
55527       (arg1)->LoadFromString((std::string const &)*arg2);
55528     } catch (std::out_of_range& e) {
55529       {
55530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55531       };
55532     } catch (std::exception& e) {
55533       {
55534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55535       };
55536     } catch (...) {
55537       {
55538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55539       };
55540     }
55541   }
55542
55543   //argout typemap for const std::string&
55544
55545 }
55546
55547
55548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
55549   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55550   Dali::Property::Map *arg2 = 0 ;
55551
55552   arg1 = (Dali::Toolkit::Builder *)jarg1;
55553   arg2 = (Dali::Property::Map *)jarg2;
55554   if (!arg2) {
55555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55556     return ;
55557   }
55558   {
55559     try {
55560       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (...) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55572       };
55573     }
55574   }
55575 }
55576
55577
55578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
55579   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55580   std::string *arg2 = 0 ;
55581   Dali::Property::Value *arg3 = 0 ;
55582
55583   arg1 = (Dali::Toolkit::Builder *)jarg1;
55584   if (!jarg2) {
55585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55586     return ;
55587   }
55588   std::string arg2_str(jarg2);
55589   arg2 = &arg2_str;
55590   arg3 = (Dali::Property::Value *)jarg3;
55591   if (!arg3) {
55592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
55593     return ;
55594   }
55595   {
55596     try {
55597       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
55598     } catch (std::out_of_range& e) {
55599       {
55600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55601       };
55602     } catch (std::exception& e) {
55603       {
55604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55605       };
55606     } catch (...) {
55607       {
55608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55609       };
55610     }
55611   }
55612
55613   //argout typemap for const std::string&
55614
55615 }
55616
55617
55618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
55619   void * jresult ;
55620   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55621   Dali::Property::Map *result = 0 ;
55622
55623   arg1 = (Dali::Toolkit::Builder *)jarg1;
55624   {
55625     try {
55626       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
55627     } catch (std::out_of_range& e) {
55628       {
55629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55630       };
55631     } catch (std::exception& e) {
55632       {
55633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55634       };
55635     } catch (...) {
55636       {
55637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55638       };
55639     }
55640   }
55641   jresult = (void *)result;
55642   return jresult;
55643 }
55644
55645
55646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
55647   void * jresult ;
55648   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55649   std::string *arg2 = 0 ;
55650   Dali::Property::Value *result = 0 ;
55651
55652   arg1 = (Dali::Toolkit::Builder *)jarg1;
55653   if (!jarg2) {
55654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55655     return 0;
55656   }
55657   std::string arg2_str(jarg2);
55658   arg2 = &arg2_str;
55659   {
55660     try {
55661       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
55662     } catch (std::out_of_range& e) {
55663       {
55664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55665       };
55666     } catch (std::exception& e) {
55667       {
55668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55669       };
55670     } catch (...) {
55671       {
55672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55673       };
55674     }
55675   }
55676   jresult = (void *)result;
55677
55678   //argout typemap for const std::string&
55679
55680   return jresult;
55681 }
55682
55683
55684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
55685   void * jresult ;
55686   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55687   std::string *arg2 = 0 ;
55688   Dali::Animation result;
55689
55690   arg1 = (Dali::Toolkit::Builder *)jarg1;
55691   if (!jarg2) {
55692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55693     return 0;
55694   }
55695   std::string arg2_str(jarg2);
55696   arg2 = &arg2_str;
55697   {
55698     try {
55699       result = (arg1)->CreateAnimation((std::string const &)*arg2);
55700     } catch (std::out_of_range& e) {
55701       {
55702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55703       };
55704     } catch (std::exception& e) {
55705       {
55706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55707       };
55708     } catch (...) {
55709       {
55710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55711       };
55712     }
55713   }
55714   jresult = new Dali::Animation((const Dali::Animation &)result);
55715
55716   //argout typemap for const std::string&
55717
55718   return jresult;
55719 }
55720
55721
55722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55723   void * jresult ;
55724   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55725   std::string *arg2 = 0 ;
55726   Dali::Property::Map *arg3 = 0 ;
55727   Dali::Animation result;
55728
55729   arg1 = (Dali::Toolkit::Builder *)jarg1;
55730   if (!jarg2) {
55731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55732     return 0;
55733   }
55734   std::string arg2_str(jarg2);
55735   arg2 = &arg2_str;
55736   arg3 = (Dali::Property::Map *)jarg3;
55737   if (!arg3) {
55738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55739     return 0;
55740   }
55741   {
55742     try {
55743       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55744     } catch (std::out_of_range& e) {
55745       {
55746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55747       };
55748     } catch (std::exception& e) {
55749       {
55750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55751       };
55752     } catch (...) {
55753       {
55754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55755       };
55756     }
55757   }
55758   jresult = new Dali::Animation((const Dali::Animation &)result);
55759
55760   //argout typemap for const std::string&
55761
55762   return jresult;
55763 }
55764
55765
55766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
55767   void * jresult ;
55768   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55769   std::string *arg2 = 0 ;
55770   Dali::Actor arg3 ;
55771   Dali::Actor *argp3 ;
55772   Dali::Animation result;
55773
55774   arg1 = (Dali::Toolkit::Builder *)jarg1;
55775   if (!jarg2) {
55776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55777     return 0;
55778   }
55779   std::string arg2_str(jarg2);
55780   arg2 = &arg2_str;
55781   argp3 = (Dali::Actor *)jarg3;
55782   if (!argp3) {
55783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55784     return 0;
55785   }
55786   arg3 = *argp3;
55787   {
55788     try {
55789       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
55790     } catch (std::out_of_range& e) {
55791       {
55792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55793       };
55794     } catch (std::exception& e) {
55795       {
55796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55797       };
55798     } catch (...) {
55799       {
55800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55801       };
55802     }
55803   }
55804   jresult = new Dali::Animation((const Dali::Animation &)result);
55805
55806   //argout typemap for const std::string&
55807
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
55813   void * jresult ;
55814   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55815   std::string *arg2 = 0 ;
55816   Dali::Property::Map *arg3 = 0 ;
55817   Dali::Actor arg4 ;
55818   Dali::Actor *argp4 ;
55819   Dali::Animation result;
55820
55821   arg1 = (Dali::Toolkit::Builder *)jarg1;
55822   if (!jarg2) {
55823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55824     return 0;
55825   }
55826   std::string arg2_str(jarg2);
55827   arg2 = &arg2_str;
55828   arg3 = (Dali::Property::Map *)jarg3;
55829   if (!arg3) {
55830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55831     return 0;
55832   }
55833   argp4 = (Dali::Actor *)jarg4;
55834   if (!argp4) {
55835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55836     return 0;
55837   }
55838   arg4 = *argp4;
55839   {
55840     try {
55841       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
55842     } catch (std::out_of_range& e) {
55843       {
55844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55845       };
55846     } catch (std::exception& e) {
55847       {
55848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55849       };
55850     } catch (...) {
55851       {
55852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55853       };
55854     }
55855   }
55856   jresult = new Dali::Animation((const Dali::Animation &)result);
55857
55858   //argout typemap for const std::string&
55859
55860   return jresult;
55861 }
55862
55863
55864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
55865   void * jresult ;
55866   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55867   std::string *arg2 = 0 ;
55868   Dali::BaseHandle result;
55869
55870   arg1 = (Dali::Toolkit::Builder *)jarg1;
55871   if (!jarg2) {
55872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55873     return 0;
55874   }
55875   std::string arg2_str(jarg2);
55876   arg2 = &arg2_str;
55877   {
55878     try {
55879       result = (arg1)->Create((std::string const &)*arg2);
55880     } catch (std::out_of_range& e) {
55881       {
55882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55883       };
55884     } catch (std::exception& e) {
55885       {
55886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55887       };
55888     } catch (...) {
55889       {
55890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55891       };
55892     }
55893   }
55894   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55895
55896   //argout typemap for const std::string&
55897
55898   return jresult;
55899 }
55900
55901
55902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
55903   void * jresult ;
55904   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55905   std::string *arg2 = 0 ;
55906   Dali::Property::Map *arg3 = 0 ;
55907   Dali::BaseHandle result;
55908
55909   arg1 = (Dali::Toolkit::Builder *)jarg1;
55910   if (!jarg2) {
55911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55912     return 0;
55913   }
55914   std::string arg2_str(jarg2);
55915   arg2 = &arg2_str;
55916   arg3 = (Dali::Property::Map *)jarg3;
55917   if (!arg3) {
55918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
55919     return 0;
55920   }
55921   {
55922     try {
55923       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
55924     } catch (std::out_of_range& e) {
55925       {
55926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55927       };
55928     } catch (std::exception& e) {
55929       {
55930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55931       };
55932     } catch (...) {
55933       {
55934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55935       };
55936     }
55937   }
55938   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55939
55940   //argout typemap for const std::string&
55941
55942   return jresult;
55943 }
55944
55945
55946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
55947   void * jresult ;
55948   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55949   std::string *arg2 = 0 ;
55950   Dali::BaseHandle result;
55951
55952   arg1 = (Dali::Toolkit::Builder *)jarg1;
55953   if (!jarg2) {
55954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55955     return 0;
55956   }
55957   std::string arg2_str(jarg2);
55958   arg2 = &arg2_str;
55959   {
55960     try {
55961       result = (arg1)->CreateFromJson((std::string const &)*arg2);
55962     } catch (std::out_of_range& e) {
55963       {
55964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55965       };
55966     } catch (std::exception& e) {
55967       {
55968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55969       };
55970     } catch (...) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55973       };
55974     }
55975   }
55976   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
55977
55978   //argout typemap for const std::string&
55979
55980   return jresult;
55981 }
55982
55983
55984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
55985   unsigned int jresult ;
55986   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
55987   std::string *arg2 = 0 ;
55988   Dali::Handle *arg3 = 0 ;
55989   bool result;
55990
55991   arg1 = (Dali::Toolkit::Builder *)jarg1;
55992   if (!jarg2) {
55993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55994     return 0;
55995   }
55996   std::string arg2_str(jarg2);
55997   arg2 = &arg2_str;
55998   arg3 = (Dali::Handle *)jarg3;
55999   if (!arg3) {
56000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
56001     return 0;
56002   }
56003   {
56004     try {
56005       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
56006     } catch (std::out_of_range& e) {
56007       {
56008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (std::exception& e) {
56011       {
56012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (...) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56017       };
56018     }
56019   }
56020   jresult = result;
56021
56022   //argout typemap for const std::string&
56023
56024   return jresult;
56025 }
56026
56027
56028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
56029   unsigned int jresult ;
56030   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56031   Dali::Handle *arg2 = 0 ;
56032   std::string *arg3 = 0 ;
56033   bool result;
56034
56035   arg1 = (Dali::Toolkit::Builder *)jarg1;
56036   arg2 = (Dali::Handle *)jarg2;
56037   if (!arg2) {
56038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
56039     return 0;
56040   }
56041   if (!jarg3) {
56042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56043     return 0;
56044   }
56045   std::string arg3_str(jarg3);
56046   arg3 = &arg3_str;
56047   {
56048     try {
56049       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
56050     } catch (std::out_of_range& e) {
56051       {
56052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56053       };
56054     } catch (std::exception& e) {
56055       {
56056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56061       };
56062     }
56063   }
56064   jresult = result;
56065
56066   //argout typemap for const std::string&
56067
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
56073   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56074   Dali::Actor arg2 ;
56075   Dali::Actor *argp2 ;
56076
56077   arg1 = (Dali::Toolkit::Builder *)jarg1;
56078   argp2 = (Dali::Actor *)jarg2;
56079   if (!argp2) {
56080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56081     return ;
56082   }
56083   arg2 = *argp2;
56084   {
56085     try {
56086       (arg1)->AddActors(arg2);
56087     } catch (std::out_of_range& e) {
56088       {
56089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56090       };
56091     } catch (std::exception& e) {
56092       {
56093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56094       };
56095     } catch (...) {
56096       {
56097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56098       };
56099     }
56100   }
56101 }
56102
56103
56104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
56105   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56106   std::string *arg2 = 0 ;
56107   Dali::Actor arg3 ;
56108   Dali::Actor *argp3 ;
56109
56110   arg1 = (Dali::Toolkit::Builder *)jarg1;
56111   if (!jarg2) {
56112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56113     return ;
56114   }
56115   std::string arg2_str(jarg2);
56116   arg2 = &arg2_str;
56117   argp3 = (Dali::Actor *)jarg3;
56118   if (!argp3) {
56119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56120     return ;
56121   }
56122   arg3 = *argp3;
56123   {
56124     try {
56125       (arg1)->AddActors((std::string const &)*arg2,arg3);
56126     } catch (std::out_of_range& e) {
56127       {
56128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56129       };
56130     } catch (std::exception& e) {
56131       {
56132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56133       };
56134     } catch (...) {
56135       {
56136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56137       };
56138     }
56139   }
56140
56141   //argout typemap for const std::string&
56142
56143 }
56144
56145
56146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
56147   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56148   std::string *arg2 = 0 ;
56149
56150   arg1 = (Dali::Toolkit::Builder *)jarg1;
56151   if (!jarg2) {
56152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56153     return ;
56154   }
56155   std::string arg2_str(jarg2);
56156   arg2 = &arg2_str;
56157   {
56158     try {
56159       (arg1)->CreateRenderTask((std::string const &)*arg2);
56160     } catch (std::out_of_range& e) {
56161       {
56162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56163       };
56164     } catch (std::exception& e) {
56165       {
56166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56167       };
56168     } catch (...) {
56169       {
56170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56171       };
56172     }
56173   }
56174
56175   //argout typemap for const std::string&
56176
56177 }
56178
56179
56180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
56181   void * jresult ;
56182   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56183   std::string *arg2 = 0 ;
56184   Dali::FrameBufferImage result;
56185
56186   arg1 = (Dali::Toolkit::Builder *)jarg1;
56187   if (!jarg2) {
56188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56189     return 0;
56190   }
56191   std::string arg2_str(jarg2);
56192   arg2 = &arg2_str;
56193   {
56194     try {
56195       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
56196     } catch (std::out_of_range& e) {
56197       {
56198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56199       };
56200     } catch (std::exception& e) {
56201       {
56202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56203       };
56204     } catch (...) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56207       };
56208     }
56209   }
56210   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
56211
56212   //argout typemap for const std::string&
56213
56214   return jresult;
56215 }
56216
56217
56218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
56219   void * jresult ;
56220   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56221   std::string *arg2 = 0 ;
56222   Dali::Path result;
56223
56224   arg1 = (Dali::Toolkit::Builder *)jarg1;
56225   if (!jarg2) {
56226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56227     return 0;
56228   }
56229   std::string arg2_str(jarg2);
56230   arg2 = &arg2_str;
56231   {
56232     try {
56233       result = (arg1)->GetPath((std::string const &)*arg2);
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248   jresult = new Dali::Path((const Dali::Path &)result);
56249
56250   //argout typemap for const std::string&
56251
56252   return jresult;
56253 }
56254
56255
56256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
56257   void * jresult ;
56258   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56259   std::string *arg2 = 0 ;
56260   Dali::PathConstrainer result;
56261
56262   arg1 = (Dali::Toolkit::Builder *)jarg1;
56263   if (!jarg2) {
56264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56265     return 0;
56266   }
56267   std::string arg2_str(jarg2);
56268   arg2 = &arg2_str;
56269   {
56270     try {
56271       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
56272     } catch (std::out_of_range& e) {
56273       {
56274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (std::exception& e) {
56277       {
56278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56279       };
56280     } catch (...) {
56281       {
56282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56283       };
56284     }
56285   }
56286   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
56287
56288   //argout typemap for const std::string&
56289
56290   return jresult;
56291 }
56292
56293
56294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
56295   void * jresult ;
56296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56297   std::string *arg2 = 0 ;
56298   Dali::LinearConstrainer result;
56299
56300   arg1 = (Dali::Toolkit::Builder *)jarg1;
56301   if (!jarg2) {
56302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56303     return 0;
56304   }
56305   std::string arg2_str(jarg2);
56306   arg2 = &arg2_str;
56307   {
56308     try {
56309       result = (arg1)->GetLinearConstrainer((std::string 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 = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
56325
56326   //argout typemap for const std::string&
56327
56328   return jresult;
56329 }
56330
56331
56332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
56333   void * jresult ;
56334   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56335   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
56336
56337   arg1 = (Dali::Toolkit::Builder *)jarg1;
56338   {
56339     try {
56340       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
56341     } catch (std::out_of_range& e) {
56342       {
56343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56344       };
56345     } catch (std::exception& e) {
56346       {
56347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56352       };
56353     }
56354   }
56355   jresult = (void *)result;
56356   return jresult;
56357 }
56358
56359
56360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
56361   void * jresult ;
56362   Dali::Toolkit::TransitionData *result = 0 ;
56363
56364   {
56365     try {
56366       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56374       };
56375     } catch (...) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56378       };
56379     }
56380   }
56381   jresult = (void *)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
56387   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56388
56389   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56390   {
56391     try {
56392       delete arg1;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56404       };
56405     }
56406   }
56407 }
56408
56409
56410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
56411   void * jresult ;
56412   Dali::Property::Map *arg1 = 0 ;
56413   Dali::Toolkit::TransitionData result;
56414
56415   arg1 = (Dali::Property::Map *)jarg1;
56416   if (!arg1) {
56417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56418     return 0;
56419   }
56420   {
56421     try {
56422       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
56423     } catch (std::out_of_range& e) {
56424       {
56425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (std::exception& e) {
56428       {
56429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56434       };
56435     }
56436   }
56437   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56438   return jresult;
56439 }
56440
56441
56442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
56443   void * jresult ;
56444   Dali::Property::Array *arg1 = 0 ;
56445   Dali::Toolkit::TransitionData result;
56446
56447   arg1 = (Dali::Property::Array *)jarg1;
56448   if (!arg1) {
56449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
56450     return 0;
56451   }
56452   {
56453     try {
56454       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
56455     } catch (std::out_of_range& e) {
56456       {
56457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56458       };
56459     } catch (std::exception& e) {
56460       {
56461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56462       };
56463     } catch (...) {
56464       {
56465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56466       };
56467     }
56468   }
56469   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56470   return jresult;
56471 }
56472
56473
56474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
56475   void * jresult ;
56476   Dali::BaseHandle arg1 ;
56477   Dali::BaseHandle *argp1 ;
56478   Dali::Toolkit::TransitionData result;
56479
56480   argp1 = (Dali::BaseHandle *)jarg1;
56481   if (!argp1) {
56482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
56483     return 0;
56484   }
56485   arg1 = *argp1;
56486   {
56487     try {
56488       result = Dali::Toolkit::TransitionData::DownCast(arg1);
56489     } catch (std::out_of_range& e) {
56490       {
56491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56492       };
56493     } catch (std::exception& e) {
56494       {
56495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56496       };
56497     } catch (...) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56500       };
56501     }
56502   }
56503   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
56504   return jresult;
56505 }
56506
56507
56508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
56509   void * jresult ;
56510   Dali::Toolkit::TransitionData *arg1 = 0 ;
56511   Dali::Toolkit::TransitionData *result = 0 ;
56512
56513   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56514   if (!arg1) {
56515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56516     return 0;
56517   }
56518   {
56519     try {
56520       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56532       };
56533     }
56534   }
56535   jresult = (void *)result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
56541   void * jresult ;
56542   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56543   Dali::Toolkit::TransitionData *arg2 = 0 ;
56544   Dali::Toolkit::TransitionData *result = 0 ;
56545
56546   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56547   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
56548   if (!arg2) {
56549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
56550     return 0;
56551   }
56552   {
56553     try {
56554       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
56555     } catch (std::out_of_range& e) {
56556       {
56557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56558       };
56559     } catch (std::exception& e) {
56560       {
56561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56562       };
56563     } catch (...) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56566       };
56567     }
56568   }
56569   jresult = (void *)result;
56570   return jresult;
56571 }
56572
56573
56574 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
56575   unsigned long jresult ;
56576   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56577   size_t result;
56578
56579   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56580   {
56581     try {
56582       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
56583     } catch (std::out_of_range& e) {
56584       {
56585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56586       };
56587     } catch (std::exception& e) {
56588       {
56589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56590       };
56591     } catch (...) {
56592       {
56593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56594       };
56595     }
56596   }
56597   jresult = (unsigned long)result;
56598   return jresult;
56599 }
56600
56601
56602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
56603   void * jresult ;
56604   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
56605   size_t arg2 ;
56606   Dali::Property::Map result;
56607
56608   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
56609   arg2 = (size_t)jarg2;
56610   {
56611     try {
56612       result = (arg1)->GetAnimatorAt(arg2);
56613     } catch (std::out_of_range& e) {
56614       {
56615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56616       };
56617     } catch (std::exception& e) {
56618       {
56619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (...) {
56622       {
56623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56624       };
56625     }
56626   }
56627   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
56628   return jresult;
56629 }
56630
56631
56632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
56633   void * jresult ;
56634   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
56635   Dali::Toolkit::TransitionData *result = 0 ;
56636
56637   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
56638   {
56639     try {
56640       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
56641     } catch (std::out_of_range& e) {
56642       {
56643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56644       };
56645     } catch (std::exception& e) {
56646       {
56647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56648       };
56649     } catch (...) {
56650       {
56651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56652       };
56653     }
56654   }
56655   jresult = (void *)result;
56656   return jresult;
56657 }
56658
56659
56660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
56661   int jresult ;
56662   int result;
56663
56664   {
56665     try {
56666       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
56667     } catch (std::out_of_range& e) {
56668       {
56669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56670       };
56671     } catch (std::exception& e) {
56672       {
56673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56674       };
56675     } catch (...) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56678       };
56679     }
56680   }
56681   jresult = (int)result;
56682   return jresult;
56683 }
56684
56685
56686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
56687   int jresult ;
56688   int result;
56689
56690   {
56691     try {
56692       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (...) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56704       };
56705     }
56706   }
56707   jresult = (int)result;
56708   return jresult;
56709 }
56710
56711
56712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
56713   int jresult ;
56714   int result;
56715
56716   {
56717     try {
56718       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
56719     } catch (std::out_of_range& e) {
56720       {
56721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56722       };
56723     } catch (std::exception& e) {
56724       {
56725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56726       };
56727     } catch (...) {
56728       {
56729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56730       };
56731     }
56732   }
56733   jresult = (int)result;
56734   return jresult;
56735 }
56736
56737
56738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
56739   int jresult ;
56740   int result;
56741
56742   {
56743     try {
56744       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
56745     } catch (std::out_of_range& e) {
56746       {
56747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56748       };
56749     } catch (std::exception& e) {
56750       {
56751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56752       };
56753     } catch (...) {
56754       {
56755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56756       };
56757     }
56758   }
56759   jresult = (int)result;
56760   return jresult;
56761 }
56762
56763
56764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
56765   int jresult ;
56766   int result;
56767
56768   {
56769     try {
56770       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
56771     } catch (std::out_of_range& e) {
56772       {
56773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56774       };
56775     } catch (std::exception& e) {
56776       {
56777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56778       };
56779     } catch (...) {
56780       {
56781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56782       };
56783     }
56784   }
56785   jresult = (int)result;
56786   return jresult;
56787 }
56788
56789
56790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
56791   int jresult ;
56792   int result;
56793
56794   {
56795     try {
56796       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
56797     } catch (std::out_of_range& e) {
56798       {
56799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56800       };
56801     } catch (std::exception& e) {
56802       {
56803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56804       };
56805     } catch (...) {
56806       {
56807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56808       };
56809     }
56810   }
56811   jresult = (int)result;
56812   return jresult;
56813 }
56814
56815
56816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
56817   int jresult ;
56818   int result;
56819
56820   {
56821     try {
56822       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
56823     } catch (std::out_of_range& e) {
56824       {
56825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56826       };
56827     } catch (std::exception& e) {
56828       {
56829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56830       };
56831     } catch (...) {
56832       {
56833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56834       };
56835     }
56836   }
56837   jresult = (int)result;
56838   return jresult;
56839 }
56840
56841
56842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
56843   int jresult ;
56844   int result;
56845
56846   {
56847     try {
56848       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
56849     } catch (std::out_of_range& e) {
56850       {
56851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56852       };
56853     } catch (std::exception& e) {
56854       {
56855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56856       };
56857     } catch (...) {
56858       {
56859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56860       };
56861     }
56862   }
56863   jresult = (int)result;
56864   return jresult;
56865 }
56866
56867
56868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
56869   int jresult ;
56870   int result;
56871
56872   {
56873     try {
56874       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
56875     } catch (std::out_of_range& e) {
56876       {
56877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56878       };
56879     } catch (std::exception& e) {
56880       {
56881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56882       };
56883     } catch (...) {
56884       {
56885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56886       };
56887     }
56888   }
56889   jresult = (int)result;
56890   return jresult;
56891 }
56892
56893
56894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
56895   int jresult ;
56896   int result;
56897
56898   {
56899     try {
56900       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
56901     } catch (std::out_of_range& e) {
56902       {
56903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56904       };
56905     } catch (std::exception& e) {
56906       {
56907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56908       };
56909     } catch (...) {
56910       {
56911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56912       };
56913     }
56914   }
56915   jresult = (int)result;
56916   return jresult;
56917 }
56918
56919
56920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
56921   int jresult ;
56922   int result;
56923
56924   {
56925     try {
56926       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
56927     } catch (std::out_of_range& e) {
56928       {
56929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (std::exception& e) {
56932       {
56933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56934       };
56935     } catch (...) {
56936       {
56937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56938       };
56939     }
56940   }
56941   jresult = (int)result;
56942   return jresult;
56943 }
56944
56945
56946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
56947   int jresult ;
56948   int result;
56949
56950   {
56951     try {
56952       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
56953     } catch (std::out_of_range& e) {
56954       {
56955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (std::exception& e) {
56958       {
56959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56964       };
56965     }
56966   }
56967   jresult = (int)result;
56968   return jresult;
56969 }
56970
56971
56972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
56973   int jresult ;
56974   int result;
56975
56976   {
56977     try {
56978       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
56979     } catch (std::out_of_range& e) {
56980       {
56981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56982       };
56983     } catch (std::exception& e) {
56984       {
56985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56986       };
56987     } catch (...) {
56988       {
56989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56990       };
56991     }
56992   }
56993   jresult = (int)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
56999   int jresult ;
57000   int result;
57001
57002   {
57003     try {
57004       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
57005     } catch (std::out_of_range& e) {
57006       {
57007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (std::exception& e) {
57010       {
57011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019   jresult = (int)result;
57020   return jresult;
57021 }
57022
57023
57024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
57025   void * jresult ;
57026   Dali::Toolkit::Control result;
57027
57028   {
57029     try {
57030       result = Dali::Toolkit::Internal::Control::New();
57031     } catch (std::out_of_range& e) {
57032       {
57033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57034       };
57035     } catch (std::exception& e) {
57036       {
57037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57042       };
57043     }
57044   }
57045   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
57046   return jresult;
57047 }
57048
57049
57050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
57051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57052   std::string *arg2 = 0 ;
57053
57054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57055   if (!jarg2) {
57056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57057     return ;
57058   }
57059   std::string arg2_str(jarg2);
57060   arg2 = &arg2_str;
57061   {
57062     try {
57063       (arg1)->SetStyleName((std::string const &)*arg2);
57064     } catch (std::out_of_range& e) {
57065       {
57066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57067       };
57068     } catch (std::exception& e) {
57069       {
57070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57071       };
57072     } catch (...) {
57073       {
57074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57075       };
57076     }
57077   }
57078
57079   //argout typemap for const std::string&
57080
57081 }
57082
57083
57084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
57085   char * jresult ;
57086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57087   std::string *result = 0 ;
57088
57089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57090   {
57091     try {
57092       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
57093     } catch (std::out_of_range& e) {
57094       {
57095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57096       };
57097     } catch (std::exception& e) {
57098       {
57099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57100       };
57101     } catch (...) {
57102       {
57103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57104       };
57105     }
57106   }
57107   jresult = SWIG_csharp_string_callback(result->c_str());
57108   return jresult;
57109 }
57110
57111
57112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
57113   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57114   Dali::Vector4 *arg2 = 0 ;
57115
57116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57117   arg2 = (Dali::Vector4 *)jarg2;
57118   if (!arg2) {
57119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
57120     return ;
57121   }
57122   {
57123     try {
57124       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
57125     } catch (std::out_of_range& e) {
57126       {
57127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57128       };
57129     } catch (std::exception& e) {
57130       {
57131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57132       };
57133     } catch (...) {
57134       {
57135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57136       };
57137     }
57138   }
57139 }
57140
57141
57142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
57143   void * jresult ;
57144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57145   Dali::Vector4 result;
57146
57147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57148   {
57149     try {
57150       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
57151     } catch (std::out_of_range& e) {
57152       {
57153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57154       };
57155     } catch (std::exception& e) {
57156       {
57157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57158       };
57159     } catch (...) {
57160       {
57161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57162       };
57163     }
57164   }
57165   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
57166   return jresult;
57167 }
57168
57169
57170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
57171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57172   Dali::Image arg2 ;
57173   Dali::Image *argp2 ;
57174
57175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57176   argp2 = (Dali::Image *)jarg2;
57177   if (!argp2) {
57178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
57179     return ;
57180   }
57181   arg2 = *argp2;
57182   {
57183     try {
57184       (arg1)->SetBackgroundImage(arg2);
57185     } catch (std::out_of_range& e) {
57186       {
57187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57188       };
57189     } catch (std::exception& e) {
57190       {
57191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57192       };
57193     } catch (...) {
57194       {
57195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57196       };
57197     }
57198   }
57199 }
57200
57201
57202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
57203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57204   Dali::Property::Map *arg2 = 0 ;
57205
57206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57207   arg2 = (Dali::Property::Map *)jarg2;
57208   if (!arg2) {
57209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57210     return ;
57211   }
57212   {
57213     try {
57214       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
57215     } catch (std::out_of_range& e) {
57216       {
57217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57218       };
57219     } catch (std::exception& e) {
57220       {
57221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57222       };
57223     } catch (...) {
57224       {
57225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57226       };
57227     }
57228   }
57229 }
57230
57231
57232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
57233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57234
57235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57236   {
57237     try {
57238       (arg1)->ClearBackground();
57239     } catch (std::out_of_range& e) {
57240       {
57241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57242       };
57243     } catch (std::exception& e) {
57244       {
57245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57246       };
57247     } catch (...) {
57248       {
57249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57250       };
57251     }
57252   }
57253 }
57254
57255
57256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
57257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57258   Dali::Gesture::Type arg2 ;
57259
57260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57261   arg2 = (Dali::Gesture::Type)jarg2;
57262   {
57263     try {
57264       (arg1)->EnableGestureDetection(arg2);
57265     } catch (std::out_of_range& e) {
57266       {
57267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57268       };
57269     } catch (std::exception& e) {
57270       {
57271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57272       };
57273     } catch (...) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57276       };
57277     }
57278   }
57279 }
57280
57281
57282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
57283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57284   Dali::Gesture::Type arg2 ;
57285
57286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57287   arg2 = (Dali::Gesture::Type)jarg2;
57288   {
57289     try {
57290       (arg1)->DisableGestureDetection(arg2);
57291     } catch (std::out_of_range& e) {
57292       {
57293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57294       };
57295     } catch (std::exception& e) {
57296       {
57297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57298       };
57299     } catch (...) {
57300       {
57301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57302       };
57303     }
57304   }
57305 }
57306
57307
57308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
57309   void * jresult ;
57310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57311   Dali::PinchGestureDetector result;
57312
57313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57314   {
57315     try {
57316       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
57317     } catch (std::out_of_range& e) {
57318       {
57319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (std::exception& e) {
57322       {
57323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57328       };
57329     }
57330   }
57331   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
57332   return jresult;
57333 }
57334
57335
57336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
57337   void * jresult ;
57338   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57339   Dali::PanGestureDetector result;
57340
57341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57342   {
57343     try {
57344       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
57345     } catch (std::out_of_range& e) {
57346       {
57347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57348       };
57349     } catch (std::exception& e) {
57350       {
57351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57352       };
57353     } catch (...) {
57354       {
57355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57356       };
57357     }
57358   }
57359   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
57360   return jresult;
57361 }
57362
57363
57364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
57365   void * jresult ;
57366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57367   Dali::TapGestureDetector result;
57368
57369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57370   {
57371     try {
57372       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
57373     } catch (std::out_of_range& e) {
57374       {
57375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (std::exception& e) {
57378       {
57379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57380       };
57381     } catch (...) {
57382       {
57383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57384       };
57385     }
57386   }
57387   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
57388   return jresult;
57389 }
57390
57391
57392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
57393   void * jresult ;
57394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57395   Dali::LongPressGestureDetector result;
57396
57397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57398   {
57399     try {
57400       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
57401     } catch (std::out_of_range& e) {
57402       {
57403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57404       };
57405     } catch (std::exception& e) {
57406       {
57407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57408       };
57409     } catch (...) {
57410       {
57411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57412       };
57413     }
57414   }
57415   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
57416   return jresult;
57417 }
57418
57419
57420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
57421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57422   bool arg2 ;
57423
57424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57425   arg2 = jarg2 ? true : false;
57426   {
57427     try {
57428       (arg1)->SetKeyboardNavigationSupport(arg2);
57429     } catch (std::out_of_range& e) {
57430       {
57431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57432       };
57433     } catch (std::exception& e) {
57434       {
57435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57436       };
57437     } catch (...) {
57438       {
57439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57440       };
57441     }
57442   }
57443 }
57444
57445
57446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
57447   unsigned int jresult ;
57448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57449   bool result;
57450
57451   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57452   {
57453     try {
57454       result = (bool)(arg1)->IsKeyboardNavigationSupported();
57455     } catch (std::out_of_range& e) {
57456       {
57457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57458       };
57459     } catch (std::exception& e) {
57460       {
57461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57466       };
57467     }
57468   }
57469   jresult = result;
57470   return jresult;
57471 }
57472
57473
57474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
57475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57476
57477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57478   {
57479     try {
57480       (arg1)->SetKeyInputFocus();
57481     } catch (std::out_of_range& e) {
57482       {
57483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57484       };
57485     } catch (std::exception& e) {
57486       {
57487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57488       };
57489     } catch (...) {
57490       {
57491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57492       };
57493     }
57494   }
57495 }
57496
57497
57498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
57499   unsigned int jresult ;
57500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57501   bool result;
57502
57503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57504   {
57505     try {
57506       result = (bool)(arg1)->HasKeyInputFocus();
57507     } catch (std::out_of_range& e) {
57508       {
57509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57510       };
57511     } catch (std::exception& e) {
57512       {
57513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57514       };
57515     } catch (...) {
57516       {
57517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57518       };
57519     }
57520   }
57521   jresult = result;
57522   return jresult;
57523 }
57524
57525
57526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
57527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57528
57529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57530   {
57531     try {
57532       (arg1)->ClearKeyInputFocus();
57533     } catch (std::out_of_range& e) {
57534       {
57535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57536       };
57537     } catch (std::exception& e) {
57538       {
57539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57540       };
57541     } catch (...) {
57542       {
57543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57544       };
57545     }
57546   }
57547 }
57548
57549
57550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
57551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57552   bool arg2 ;
57553
57554   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57555   arg2 = jarg2 ? true : false;
57556   {
57557     try {
57558       (arg1)->SetAsKeyboardFocusGroup(arg2);
57559     } catch (std::out_of_range& e) {
57560       {
57561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57562       };
57563     } catch (std::exception& e) {
57564       {
57565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57566       };
57567     } catch (...) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57570       };
57571     }
57572   }
57573 }
57574
57575
57576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
57577   unsigned int jresult ;
57578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57579   bool result;
57580
57581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57582   {
57583     try {
57584       result = (bool)(arg1)->IsKeyboardFocusGroup();
57585     } catch (std::out_of_range& e) {
57586       {
57587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57588       };
57589     } catch (std::exception& e) {
57590       {
57591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57596       };
57597     }
57598   }
57599   jresult = result;
57600   return jresult;
57601 }
57602
57603
57604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
57605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57606
57607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57608   {
57609     try {
57610       (arg1)->AccessibilityActivate();
57611     } catch (std::out_of_range& e) {
57612       {
57613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57614       };
57615     } catch (std::exception& e) {
57616       {
57617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57618       };
57619     } catch (...) {
57620       {
57621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57622       };
57623     }
57624   }
57625 }
57626
57627
57628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
57629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57630
57631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57632   {
57633     try {
57634       (arg1)->KeyboardEnter();
57635     } catch (std::out_of_range& e) {
57636       {
57637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57638       };
57639     } catch (std::exception& e) {
57640       {
57641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57642       };
57643     } catch (...) {
57644       {
57645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57646       };
57647     }
57648   }
57649 }
57650
57651
57652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
57653   void * jresult ;
57654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57655   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
57656
57657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57658   {
57659     try {
57660       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
57661     } catch (std::out_of_range& e) {
57662       {
57663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57664       };
57665     } catch (std::exception& e) {
57666       {
57667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57668       };
57669     } catch (...) {
57670       {
57671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57672       };
57673     }
57674   }
57675   jresult = (void *)result;
57676   return jresult;
57677 }
57678
57679
57680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
57681   void * jresult ;
57682   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57683   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57684
57685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57686   {
57687     try {
57688       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
57689     } catch (std::out_of_range& e) {
57690       {
57691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (std::exception& e) {
57694       {
57695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (...) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57700       };
57701     }
57702   }
57703   jresult = (void *)result;
57704   return jresult;
57705 }
57706
57707
57708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
57709   void * jresult ;
57710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57711   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
57712
57713   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57714   {
57715     try {
57716       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
57717     } catch (std::out_of_range& e) {
57718       {
57719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57720       };
57721     } catch (std::exception& e) {
57722       {
57723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57724       };
57725     } catch (...) {
57726       {
57727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57728       };
57729     }
57730   }
57731   jresult = (void *)result;
57732   return jresult;
57733 }
57734
57735
57736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
57737   unsigned int jresult ;
57738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57739   Dali::KeyEvent *arg2 = 0 ;
57740   bool result;
57741
57742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57743   arg2 = (Dali::KeyEvent *)jarg2;
57744   if (!arg2) {
57745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
57746     return 0;
57747   }
57748   {
57749     try {
57750       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
57751     } catch (std::out_of_range& e) {
57752       {
57753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57754       };
57755     } catch (std::exception& e) {
57756       {
57757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57758       };
57759     } catch (...) {
57760       {
57761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57762       };
57763     }
57764   }
57765   jresult = result;
57766   return jresult;
57767 }
57768
57769
57770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
57771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57772   int arg2 ;
57773   SwigDirector_ViewImpl *darg = 0;
57774
57775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57776   arg2 = (int)jarg2;
57777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57778   {
57779     try {
57780       (darg)->OnStageConnection(arg2);
57781     } catch (std::out_of_range& e) {
57782       {
57783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57784       };
57785     } catch (std::exception& e) {
57786       {
57787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57788       };
57789     } catch (...) {
57790       {
57791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57792       };
57793     }
57794   }
57795 }
57796
57797
57798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
57799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57800   int arg2 ;
57801   SwigDirector_ViewImpl *darg = 0;
57802
57803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57804   arg2 = (int)jarg2;
57805   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57806   {
57807     try {
57808       (darg)->OnStageConnectionSwigPublic(arg2);
57809     } catch (std::out_of_range& e) {
57810       {
57811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57812       };
57813     } catch (std::exception& e) {
57814       {
57815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57816       };
57817     } catch (...) {
57818       {
57819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57820       };
57821     }
57822   }
57823 }
57824
57825
57826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
57827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57828   SwigDirector_ViewImpl *darg = 0;
57829
57830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57831   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57832   {
57833     try {
57834       (darg)->OnStageDisconnection();
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57842       };
57843     } catch (...) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57846       };
57847     }
57848   }
57849 }
57850
57851
57852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
57853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57854   SwigDirector_ViewImpl *darg = 0;
57855
57856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57858   {
57859     try {
57860       (darg)->OnStageDisconnectionSwigPublic();
57861     } catch (std::out_of_range& e) {
57862       {
57863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57864       };
57865     } catch (std::exception& e) {
57866       {
57867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57868       };
57869     } catch (...) {
57870       {
57871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57872       };
57873     }
57874   }
57875 }
57876
57877
57878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
57879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57880   Dali::Actor *arg2 = 0 ;
57881   SwigDirector_ViewImpl *darg = 0;
57882
57883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57884   arg2 = (Dali::Actor *)jarg2;
57885   if (!arg2) {
57886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57887     return ;
57888   }
57889   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57890   {
57891     try {
57892       (darg)->OnChildAdd(*arg2);
57893     } catch (std::out_of_range& e) {
57894       {
57895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57896       };
57897     } catch (std::exception& e) {
57898       {
57899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57900       };
57901     } catch (...) {
57902       {
57903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57904       };
57905     }
57906   }
57907 }
57908
57909
57910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57911   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57912   Dali::Actor *arg2 = 0 ;
57913   SwigDirector_ViewImpl *darg = 0;
57914
57915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57916   arg2 = (Dali::Actor *)jarg2;
57917   if (!arg2) {
57918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57919     return ;
57920   }
57921   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57922   {
57923     try {
57924       (darg)->OnChildAddSwigPublic(*arg2);
57925     } catch (std::out_of_range& e) {
57926       {
57927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57928       };
57929     } catch (std::exception& e) {
57930       {
57931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57932       };
57933     } catch (...) {
57934       {
57935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57936       };
57937     }
57938   }
57939 }
57940
57941
57942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
57943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57944   Dali::Actor *arg2 = 0 ;
57945   SwigDirector_ViewImpl *darg = 0;
57946
57947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57948   arg2 = (Dali::Actor *)jarg2;
57949   if (!arg2) {
57950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57951     return ;
57952   }
57953   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57954   {
57955     try {
57956       (darg)->OnChildRemove(*arg2);
57957     } catch (std::out_of_range& e) {
57958       {
57959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57960       };
57961     } catch (std::exception& e) {
57962       {
57963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57964       };
57965     } catch (...) {
57966       {
57967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57968       };
57969     }
57970   }
57971 }
57972
57973
57974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
57975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
57976   Dali::Actor *arg2 = 0 ;
57977   SwigDirector_ViewImpl *darg = 0;
57978
57979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
57980   arg2 = (Dali::Actor *)jarg2;
57981   if (!arg2) {
57982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
57983     return ;
57984   }
57985   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
57986   {
57987     try {
57988       (darg)->OnChildRemoveSwigPublic(*arg2);
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57996       };
57997     } catch (...) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58000       };
58001     }
58002   }
58003 }
58004
58005
58006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
58007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58008   Dali::Property::Index arg2 ;
58009   Dali::Property::Value arg3 ;
58010   Dali::Property::Value *argp3 ;
58011   SwigDirector_ViewImpl *darg = 0;
58012
58013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58014   arg2 = (Dali::Property::Index)jarg2;
58015   argp3 = (Dali::Property::Value *)jarg3;
58016   if (!argp3) {
58017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
58018     return ;
58019   }
58020   arg3 = *argp3;
58021   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58022   {
58023     try {
58024       (darg)->OnPropertySet(arg2,arg3);
58025     } catch (std::out_of_range& e) {
58026       {
58027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58028       };
58029     } catch (std::exception& e) {
58030       {
58031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58032       };
58033     } catch (...) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58036       };
58037     }
58038   }
58039 }
58040
58041
58042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
58043   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58044   Dali::Property::Index arg2 ;
58045   Dali::Property::Value arg3 ;
58046   Dali::Property::Value *argp3 ;
58047   SwigDirector_ViewImpl *darg = 0;
58048
58049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58050   arg2 = (Dali::Property::Index)jarg2;
58051   argp3 = (Dali::Property::Value *)jarg3;
58052   if (!argp3) {
58053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
58054     return ;
58055   }
58056   arg3 = *argp3;
58057   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58058   {
58059     try {
58060       (darg)->OnPropertySetSwigPublic(arg2,arg3);
58061     } catch (std::out_of_range& e) {
58062       {
58063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58064       };
58065     } catch (std::exception& e) {
58066       {
58067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58068       };
58069     } catch (...) {
58070       {
58071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58072       };
58073     }
58074   }
58075 }
58076
58077
58078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
58079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58080   Dali::Vector3 *arg2 = 0 ;
58081   SwigDirector_ViewImpl *darg = 0;
58082
58083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58084   arg2 = (Dali::Vector3 *)jarg2;
58085   if (!arg2) {
58086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58087     return ;
58088   }
58089   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58090   {
58091     try {
58092       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
58093     } catch (std::out_of_range& e) {
58094       {
58095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58096       };
58097     } catch (std::exception& e) {
58098       {
58099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58100       };
58101     } catch (...) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58104       };
58105     }
58106   }
58107 }
58108
58109
58110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58112   Dali::Vector3 *arg2 = 0 ;
58113   SwigDirector_ViewImpl *darg = 0;
58114
58115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58116   arg2 = (Dali::Vector3 *)jarg2;
58117   if (!arg2) {
58118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58119     return ;
58120   }
58121   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58122   {
58123     try {
58124       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
58125     } catch (std::out_of_range& e) {
58126       {
58127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58128       };
58129     } catch (std::exception& e) {
58130       {
58131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58132       };
58133     } catch (...) {
58134       {
58135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58136       };
58137     }
58138   }
58139 }
58140
58141
58142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
58143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58144   Dali::Animation *arg2 = 0 ;
58145   Dali::Vector3 *arg3 = 0 ;
58146   SwigDirector_ViewImpl *darg = 0;
58147
58148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58149   arg2 = (Dali::Animation *)jarg2;
58150   if (!arg2) {
58151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58152     return ;
58153   }
58154   arg3 = (Dali::Vector3 *)jarg3;
58155   if (!arg3) {
58156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58157     return ;
58158   }
58159   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58160   {
58161     try {
58162       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
58163     } catch (std::out_of_range& e) {
58164       {
58165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58166       };
58167     } catch (std::exception& e) {
58168       {
58169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58170       };
58171     } catch (...) {
58172       {
58173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58174       };
58175     }
58176   }
58177 }
58178
58179
58180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58182   Dali::Animation *arg2 = 0 ;
58183   Dali::Vector3 *arg3 = 0 ;
58184   SwigDirector_ViewImpl *darg = 0;
58185
58186   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58187   arg2 = (Dali::Animation *)jarg2;
58188   if (!arg2) {
58189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
58190     return ;
58191   }
58192   arg3 = (Dali::Vector3 *)jarg3;
58193   if (!arg3) {
58194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
58195     return ;
58196   }
58197   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58198   {
58199     try {
58200       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
58201     } catch (std::out_of_range& e) {
58202       {
58203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58204       };
58205     } catch (std::exception& e) {
58206       {
58207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58208       };
58209     } catch (...) {
58210       {
58211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58212       };
58213     }
58214   }
58215 }
58216
58217
58218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
58219   unsigned int jresult ;
58220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58221   Dali::TouchEvent *arg2 = 0 ;
58222   SwigDirector_ViewImpl *darg = 0;
58223   bool result;
58224
58225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58226   arg2 = (Dali::TouchEvent *)jarg2;
58227   if (!arg2) {
58228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58229     return 0;
58230   }
58231   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58232   {
58233     try {
58234       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
58235     } catch (std::out_of_range& e) {
58236       {
58237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58238       };
58239     } catch (std::exception& e) {
58240       {
58241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58242       };
58243     } catch (...) {
58244       {
58245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58246       };
58247     }
58248   }
58249   jresult = result;
58250   return jresult;
58251 }
58252
58253
58254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58255   unsigned int jresult ;
58256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58257   Dali::TouchEvent *arg2 = 0 ;
58258   SwigDirector_ViewImpl *darg = 0;
58259   bool result;
58260
58261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58262   arg2 = (Dali::TouchEvent *)jarg2;
58263   if (!arg2) {
58264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
58265     return 0;
58266   }
58267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58268   {
58269     try {
58270       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58282       };
58283     }
58284   }
58285   jresult = result;
58286   return jresult;
58287 }
58288
58289
58290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
58291   unsigned int jresult ;
58292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58293   Dali::HoverEvent *arg2 = 0 ;
58294   SwigDirector_ViewImpl *darg = 0;
58295   bool result;
58296
58297   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58298   arg2 = (Dali::HoverEvent *)jarg2;
58299   if (!arg2) {
58300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58301     return 0;
58302   }
58303   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58304   {
58305     try {
58306       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (...) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58318       };
58319     }
58320   }
58321   jresult = result;
58322   return jresult;
58323 }
58324
58325
58326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58327   unsigned int jresult ;
58328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58329   Dali::HoverEvent *arg2 = 0 ;
58330   SwigDirector_ViewImpl *darg = 0;
58331   bool result;
58332
58333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58334   arg2 = (Dali::HoverEvent *)jarg2;
58335   if (!arg2) {
58336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
58337     return 0;
58338   }
58339   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58340   {
58341     try {
58342       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
58343     } catch (std::out_of_range& e) {
58344       {
58345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (std::exception& e) {
58348       {
58349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (...) {
58352       {
58353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58354       };
58355     }
58356   }
58357   jresult = result;
58358   return jresult;
58359 }
58360
58361
58362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
58363   unsigned int jresult ;
58364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58365   Dali::KeyEvent *arg2 = 0 ;
58366   SwigDirector_ViewImpl *darg = 0;
58367   bool result;
58368
58369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58370   arg2 = (Dali::KeyEvent *)jarg2;
58371   if (!arg2) {
58372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58373     return 0;
58374   }
58375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58376   {
58377     try {
58378       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
58379     } catch (std::out_of_range& e) {
58380       {
58381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58382       };
58383     } catch (std::exception& e) {
58384       {
58385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58386       };
58387     } catch (...) {
58388       {
58389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58390       };
58391     }
58392   }
58393   jresult = result;
58394   return jresult;
58395 }
58396
58397
58398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58399   unsigned int jresult ;
58400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58401   Dali::KeyEvent *arg2 = 0 ;
58402   SwigDirector_ViewImpl *darg = 0;
58403   bool result;
58404
58405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58406   arg2 = (Dali::KeyEvent *)jarg2;
58407   if (!arg2) {
58408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
58409     return 0;
58410   }
58411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58412   {
58413     try {
58414       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
58415     } catch (std::out_of_range& e) {
58416       {
58417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58418       };
58419     } catch (std::exception& e) {
58420       {
58421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58422       };
58423     } catch (...) {
58424       {
58425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58426       };
58427     }
58428   }
58429   jresult = result;
58430   return jresult;
58431 }
58432
58433
58434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
58435   unsigned int jresult ;
58436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58437   Dali::WheelEvent *arg2 = 0 ;
58438   SwigDirector_ViewImpl *darg = 0;
58439   bool result;
58440
58441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58442   arg2 = (Dali::WheelEvent *)jarg2;
58443   if (!arg2) {
58444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58445     return 0;
58446   }
58447   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58448   {
58449     try {
58450       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
58451     } catch (std::out_of_range& e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58454       };
58455     } catch (std::exception& e) {
58456       {
58457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58458       };
58459     } catch (...) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58462       };
58463     }
58464   }
58465   jresult = result;
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
58471   unsigned int jresult ;
58472   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58473   Dali::WheelEvent *arg2 = 0 ;
58474   SwigDirector_ViewImpl *darg = 0;
58475   bool result;
58476
58477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58478   arg2 = (Dali::WheelEvent *)jarg2;
58479   if (!arg2) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
58481     return 0;
58482   }
58483   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58484   {
58485     try {
58486       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
58487     } catch (std::out_of_range& e) {
58488       {
58489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58490       };
58491     } catch (std::exception& e) {
58492       {
58493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58494       };
58495     } catch (...) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58498       };
58499     }
58500   }
58501   jresult = result;
58502   return jresult;
58503 }
58504
58505
58506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
58507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58508   Dali::Vector2 *arg2 = 0 ;
58509   Dali::RelayoutContainer *arg3 = 0 ;
58510   SwigDirector_ViewImpl *darg = 0;
58511
58512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58513   arg2 = (Dali::Vector2 *)jarg2;
58514   if (!arg2) {
58515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58516     return ;
58517   }
58518   arg3 = (Dali::RelayoutContainer *)jarg3;
58519   if (!arg3) {
58520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58521     return ;
58522   }
58523   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58524   {
58525     try {
58526       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
58527     } catch (std::out_of_range& e) {
58528       {
58529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58530       };
58531     } catch (std::exception& e) {
58532       {
58533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58534       };
58535     } catch (...) {
58536       {
58537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58538       };
58539     }
58540   }
58541 }
58542
58543
58544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
58545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58546   Dali::Vector2 *arg2 = 0 ;
58547   Dali::RelayoutContainer *arg3 = 0 ;
58548   SwigDirector_ViewImpl *darg = 0;
58549
58550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58551   arg2 = (Dali::Vector2 *)jarg2;
58552   if (!arg2) {
58553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
58554     return ;
58555   }
58556   arg3 = (Dali::RelayoutContainer *)jarg3;
58557   if (!arg3) {
58558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
58559     return ;
58560   }
58561   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58562   {
58563     try {
58564       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
58565     } catch (std::out_of_range& e) {
58566       {
58567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58568       };
58569     } catch (std::exception& e) {
58570       {
58571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58572       };
58573     } catch (...) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58576       };
58577     }
58578   }
58579 }
58580
58581
58582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
58583   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58584   Dali::ResizePolicy::Type arg2 ;
58585   Dali::Dimension::Type arg3 ;
58586   SwigDirector_ViewImpl *darg = 0;
58587
58588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58589   arg2 = (Dali::ResizePolicy::Type)jarg2;
58590   arg3 = (Dali::Dimension::Type)jarg3;
58591   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58592   {
58593     try {
58594       (darg)->OnSetResizePolicy(arg2,arg3);
58595     } catch (std::out_of_range& e) {
58596       {
58597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58598       };
58599     } catch (std::exception& e) {
58600       {
58601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58602       };
58603     } catch (...) {
58604       {
58605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58606       };
58607     }
58608   }
58609 }
58610
58611
58612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
58613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58614   Dali::ResizePolicy::Type arg2 ;
58615   Dali::Dimension::Type arg3 ;
58616   SwigDirector_ViewImpl *darg = 0;
58617
58618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58619   arg2 = (Dali::ResizePolicy::Type)jarg2;
58620   arg3 = (Dali::Dimension::Type)jarg3;
58621   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58622   {
58623     try {
58624       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
58625     } catch (std::out_of_range& e) {
58626       {
58627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58628       };
58629     } catch (std::exception& e) {
58630       {
58631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58632       };
58633     } catch (...) {
58634       {
58635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58636       };
58637     }
58638   }
58639 }
58640
58641
58642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
58643   void * jresult ;
58644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58645   SwigDirector_ViewImpl *darg = 0;
58646   Dali::Vector3 result;
58647
58648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58649   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58650   {
58651     try {
58652       result = (darg)->GetNaturalSize();
58653     } catch (std::out_of_range& e) {
58654       {
58655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58656       };
58657     } catch (std::exception& e) {
58658       {
58659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58660       };
58661     } catch (...) {
58662       {
58663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58664       };
58665     }
58666   }
58667   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58668   return jresult;
58669 }
58670
58671
58672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
58673   void * jresult ;
58674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58675   SwigDirector_ViewImpl *darg = 0;
58676   Dali::Vector3 result;
58677
58678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58680   {
58681     try {
58682       result = (darg)->GetNaturalSizeSwigPublic();
58683     } catch (std::out_of_range& e) {
58684       {
58685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58686       };
58687     } catch (std::exception& e) {
58688       {
58689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58690       };
58691     } catch (...) {
58692       {
58693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58694       };
58695     }
58696   }
58697   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
58698   return jresult;
58699 }
58700
58701
58702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
58703   float jresult ;
58704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58705   Dali::Actor *arg2 = 0 ;
58706   Dali::Dimension::Type arg3 ;
58707   SwigDirector_ViewImpl *darg = 0;
58708   float result;
58709
58710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58711   arg2 = (Dali::Actor *)jarg2;
58712   if (!arg2) {
58713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58714     return 0;
58715   }
58716   arg3 = (Dali::Dimension::Type)jarg3;
58717   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58718   {
58719     try {
58720       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (...) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58732       };
58733     }
58734   }
58735   jresult = result;
58736   return jresult;
58737 }
58738
58739
58740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
58741   float jresult ;
58742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58743   Dali::Actor *arg2 = 0 ;
58744   Dali::Dimension::Type arg3 ;
58745   SwigDirector_ViewImpl *darg = 0;
58746   float result;
58747
58748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58749   arg2 = (Dali::Actor *)jarg2;
58750   if (!arg2) {
58751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
58752     return 0;
58753   }
58754   arg3 = (Dali::Dimension::Type)jarg3;
58755   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58756   {
58757     try {
58758       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
58759     } catch (std::out_of_range& e) {
58760       {
58761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58762       };
58763     } catch (std::exception& e) {
58764       {
58765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (...) {
58768       {
58769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58770       };
58771     }
58772   }
58773   jresult = result;
58774   return jresult;
58775 }
58776
58777
58778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
58779   float jresult ;
58780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58781   float arg2 ;
58782   SwigDirector_ViewImpl *darg = 0;
58783   float result;
58784
58785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58786   arg2 = (float)jarg2;
58787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58788   {
58789     try {
58790       result = (float)(darg)->GetHeightForWidth(arg2);
58791     } catch (std::out_of_range& e) {
58792       {
58793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58794       };
58795     } catch (std::exception& e) {
58796       {
58797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58802       };
58803     }
58804   }
58805   jresult = result;
58806   return jresult;
58807 }
58808
58809
58810 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
58811   float jresult ;
58812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58813   float arg2 ;
58814   SwigDirector_ViewImpl *darg = 0;
58815   float result;
58816
58817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58818   arg2 = (float)jarg2;
58819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58820   {
58821     try {
58822       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
58823     } catch (std::out_of_range& e) {
58824       {
58825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58826       };
58827     } catch (std::exception& e) {
58828       {
58829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58830       };
58831     } catch (...) {
58832       {
58833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58834       };
58835     }
58836   }
58837   jresult = result;
58838   return jresult;
58839 }
58840
58841
58842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
58843   float jresult ;
58844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58845   float arg2 ;
58846   SwigDirector_ViewImpl *darg = 0;
58847   float result;
58848
58849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58850   arg2 = (float)jarg2;
58851   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58852   {
58853     try {
58854       result = (float)(darg)->GetWidthForHeight(arg2);
58855     } catch (std::out_of_range& e) {
58856       {
58857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (std::exception& e) {
58860       {
58861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58866       };
58867     }
58868   }
58869   jresult = result;
58870   return jresult;
58871 }
58872
58873
58874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
58875   float jresult ;
58876   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58877   float arg2 ;
58878   SwigDirector_ViewImpl *darg = 0;
58879   float result;
58880
58881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58882   arg2 = (float)jarg2;
58883   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58884   {
58885     try {
58886       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
58887     } catch (std::out_of_range& e) {
58888       {
58889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (std::exception& e) {
58892       {
58893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58898       };
58899     }
58900   }
58901   jresult = result;
58902   return jresult;
58903 }
58904
58905
58906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
58907   unsigned int jresult ;
58908   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58909   Dali::Dimension::Type arg2 ;
58910   SwigDirector_ViewImpl *darg = 0;
58911   bool result;
58912
58913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58914   arg2 = (Dali::Dimension::Type)jarg2;
58915   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58916   {
58917     try {
58918       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
58919     } catch (std::out_of_range& e) {
58920       {
58921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58922       };
58923     } catch (std::exception& e) {
58924       {
58925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58926       };
58927     } catch (...) {
58928       {
58929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58930       };
58931     }
58932   }
58933   jresult = result;
58934   return jresult;
58935 }
58936
58937
58938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
58939   unsigned int jresult ;
58940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58941   Dali::Dimension::Type arg2 ;
58942   SwigDirector_ViewImpl *darg = 0;
58943   bool result;
58944
58945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58946   arg2 = (Dali::Dimension::Type)jarg2;
58947   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58948   {
58949     try {
58950       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
58951     } catch (std::out_of_range& e) {
58952       {
58953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58954       };
58955     } catch (std::exception& e) {
58956       {
58957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58962       };
58963     }
58964   }
58965   jresult = result;
58966   return jresult;
58967 }
58968
58969
58970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
58971   unsigned int jresult ;
58972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58973   SwigDirector_ViewImpl *darg = 0;
58974   bool result;
58975
58976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58977   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
58978   {
58979     try {
58980       result = (bool)(darg)->RelayoutDependentOnChildren();
58981     } catch (std::out_of_range& e) {
58982       {
58983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (std::exception& e) {
58986       {
58987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58988       };
58989     } catch (...) {
58990       {
58991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58992       };
58993     }
58994   }
58995   jresult = result;
58996   return jresult;
58997 }
58998
58999
59000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
59001   unsigned int jresult ;
59002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59003   SwigDirector_ViewImpl *darg = 0;
59004   bool result;
59005
59006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59007   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59008   {
59009     try {
59010       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
59011     } catch (std::out_of_range& e) {
59012       {
59013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59014       };
59015     } catch (std::exception& e) {
59016       {
59017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59018       };
59019     } catch (...) {
59020       {
59021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59022       };
59023     }
59024   }
59025   jresult = result;
59026   return jresult;
59027 }
59028
59029
59030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
59031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59032   Dali::Dimension::Type arg2 ;
59033   SwigDirector_ViewImpl *darg = 0;
59034
59035   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59036   arg2 = (Dali::Dimension::Type)jarg2;
59037   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59038   {
59039     try {
59040       (darg)->OnCalculateRelayoutSize(arg2);
59041     } catch (std::out_of_range& e) {
59042       {
59043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59044       };
59045     } catch (std::exception& e) {
59046       {
59047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59048       };
59049     } catch (...) {
59050       {
59051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59052       };
59053     }
59054   }
59055 }
59056
59057
59058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
59059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59060   Dali::Dimension::Type arg2 ;
59061   SwigDirector_ViewImpl *darg = 0;
59062
59063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59064   arg2 = (Dali::Dimension::Type)jarg2;
59065   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59066   {
59067     try {
59068       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
59069     } catch (std::out_of_range& e) {
59070       {
59071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59072       };
59073     } catch (std::exception& e) {
59074       {
59075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59076       };
59077     } catch (...) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59080       };
59081     }
59082   }
59083 }
59084
59085
59086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
59087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59088   float arg2 ;
59089   Dali::Dimension::Type arg3 ;
59090   SwigDirector_ViewImpl *darg = 0;
59091
59092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59093   arg2 = (float)jarg2;
59094   arg3 = (Dali::Dimension::Type)jarg3;
59095   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59096   {
59097     try {
59098       (darg)->OnLayoutNegotiated(arg2,arg3);
59099     } catch (std::out_of_range& e) {
59100       {
59101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59102       };
59103     } catch (std::exception& e) {
59104       {
59105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59106       };
59107     } catch (...) {
59108       {
59109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59110       };
59111     }
59112   }
59113 }
59114
59115
59116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
59117   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59118   float arg2 ;
59119   Dali::Dimension::Type arg3 ;
59120   SwigDirector_ViewImpl *darg = 0;
59121
59122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59123   arg2 = (float)jarg2;
59124   arg3 = (Dali::Dimension::Type)jarg3;
59125   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59126   {
59127     try {
59128       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
59129     } catch (std::out_of_range& e) {
59130       {
59131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59132       };
59133     } catch (std::exception& e) {
59134       {
59135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59140       };
59141     }
59142   }
59143 }
59144
59145
59146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
59147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59148
59149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59150   {
59151     try {
59152       (arg1)->OnInitialize();
59153     } catch (std::out_of_range& e) {
59154       {
59155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59156       };
59157     } catch (std::exception& e) {
59158       {
59159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59160       };
59161     } catch (...) {
59162       {
59163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59164       };
59165     }
59166   }
59167 }
59168
59169
59170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
59171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59172
59173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59174   {
59175     try {
59176       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
59177     } catch (std::out_of_range& e) {
59178       {
59179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59180       };
59181     } catch (std::exception& e) {
59182       {
59183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59184       };
59185     } catch (...) {
59186       {
59187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59188       };
59189     }
59190   }
59191 }
59192
59193
59194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
59195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59196   Dali::Actor *arg2 = 0 ;
59197
59198   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59199   arg2 = (Dali::Actor *)jarg2;
59200   if (!arg2) {
59201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59202     return ;
59203   }
59204   {
59205     try {
59206       (arg1)->OnControlChildAdd(*arg2);
59207     } catch (std::out_of_range& e) {
59208       {
59209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59210       };
59211     } catch (std::exception& e) {
59212       {
59213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59214       };
59215     } catch (...) {
59216       {
59217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59218       };
59219     }
59220   }
59221 }
59222
59223
59224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59226   Dali::Actor *arg2 = 0 ;
59227
59228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59229   arg2 = (Dali::Actor *)jarg2;
59230   if (!arg2) {
59231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59232     return ;
59233   }
59234   {
59235     try {
59236       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
59237     } catch (std::out_of_range& e) {
59238       {
59239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59240       };
59241     } catch (std::exception& e) {
59242       {
59243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59248       };
59249     }
59250   }
59251 }
59252
59253
59254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
59255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59256   Dali::Actor *arg2 = 0 ;
59257
59258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59259   arg2 = (Dali::Actor *)jarg2;
59260   if (!arg2) {
59261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59262     return ;
59263   }
59264   {
59265     try {
59266       (arg1)->OnControlChildRemove(*arg2);
59267     } catch (std::out_of_range& e) {
59268       {
59269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59270       };
59271     } catch (std::exception& e) {
59272       {
59273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59274       };
59275     } catch (...) {
59276       {
59277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59278       };
59279     }
59280   }
59281 }
59282
59283
59284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59286   Dali::Actor *arg2 = 0 ;
59287
59288   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59289   arg2 = (Dali::Actor *)jarg2;
59290   if (!arg2) {
59291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59292     return ;
59293   }
59294   {
59295     try {
59296       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
59297     } catch (std::out_of_range& e) {
59298       {
59299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59300       };
59301     } catch (std::exception& e) {
59302       {
59303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59304       };
59305     } catch (...) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59308       };
59309     }
59310   }
59311 }
59312
59313
59314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
59315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59316   Dali::Toolkit::StyleManager arg2 ;
59317   Dali::StyleChange::Type arg3 ;
59318   Dali::Toolkit::StyleManager *argp2 ;
59319
59320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59321   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59322   if (!argp2) {
59323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59324     return ;
59325   }
59326   arg2 = *argp2;
59327   arg3 = (Dali::StyleChange::Type)jarg3;
59328   {
59329     try {
59330       (arg1)->OnStyleChange(arg2,arg3);
59331     } catch (std::out_of_range& e) {
59332       {
59333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59334       };
59335     } catch (std::exception& e) {
59336       {
59337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59338       };
59339     } catch (...) {
59340       {
59341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59342       };
59343     }
59344   }
59345 }
59346
59347
59348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
59349   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59350   Dali::Toolkit::StyleManager arg2 ;
59351   Dali::StyleChange::Type arg3 ;
59352   Dali::Toolkit::StyleManager *argp2 ;
59353
59354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59355   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
59356   if (!argp2) {
59357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
59358     return ;
59359   }
59360   arg2 = *argp2;
59361   arg3 = (Dali::StyleChange::Type)jarg3;
59362   {
59363     try {
59364       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
59365     } catch (std::out_of_range& e) {
59366       {
59367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59368       };
59369     } catch (std::exception& e) {
59370       {
59371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59372       };
59373     } catch (...) {
59374       {
59375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59376       };
59377     }
59378   }
59379 }
59380
59381
59382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
59383   unsigned int jresult ;
59384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59385   bool result;
59386
59387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59388   {
59389     try {
59390       result = (bool)(arg1)->OnAccessibilityActivated();
59391     } catch (std::out_of_range& e) {
59392       {
59393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59394       };
59395     } catch (std::exception& e) {
59396       {
59397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59398       };
59399     } catch (...) {
59400       {
59401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59402       };
59403     }
59404   }
59405   jresult = result;
59406   return jresult;
59407 }
59408
59409
59410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
59411   unsigned int jresult ;
59412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59413   bool result;
59414
59415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59416   {
59417     try {
59418       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
59419     } catch (std::out_of_range& e) {
59420       {
59421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59422       };
59423     } catch (std::exception& e) {
59424       {
59425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59426       };
59427     } catch (...) {
59428       {
59429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59430       };
59431     }
59432   }
59433   jresult = result;
59434   return jresult;
59435 }
59436
59437
59438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
59439   unsigned int jresult ;
59440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59441   Dali::PanGesture arg2 ;
59442   Dali::PanGesture *argp2 ;
59443   bool result;
59444
59445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59446   argp2 = (Dali::PanGesture *)jarg2;
59447   if (!argp2) {
59448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59449     return 0;
59450   }
59451   arg2 = *argp2;
59452   {
59453     try {
59454       result = (bool)(arg1)->OnAccessibilityPan(arg2);
59455     } catch (std::out_of_range& e) {
59456       {
59457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (std::exception& e) {
59460       {
59461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59462       };
59463     } catch (...) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59466       };
59467     }
59468   }
59469   jresult = result;
59470   return jresult;
59471 }
59472
59473
59474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59475   unsigned int jresult ;
59476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59477   Dali::PanGesture arg2 ;
59478   Dali::PanGesture *argp2 ;
59479   bool result;
59480
59481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59482   argp2 = (Dali::PanGesture *)jarg2;
59483   if (!argp2) {
59484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
59485     return 0;
59486   }
59487   arg2 = *argp2;
59488   {
59489     try {
59490       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
59491     } catch (std::out_of_range& e) {
59492       {
59493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59494       };
59495     } catch (std::exception& e) {
59496       {
59497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59498       };
59499     } catch (...) {
59500       {
59501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59502       };
59503     }
59504   }
59505   jresult = result;
59506   return jresult;
59507 }
59508
59509
59510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
59511   unsigned int jresult ;
59512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59513   Dali::TouchEvent *arg2 = 0 ;
59514   bool result;
59515
59516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59517   arg2 = (Dali::TouchEvent *)jarg2;
59518   if (!arg2) {
59519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59520     return 0;
59521   }
59522   {
59523     try {
59524       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59525     } catch (std::out_of_range& e) {
59526       {
59527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59528       };
59529     } catch (std::exception& e) {
59530       {
59531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (...) {
59534       {
59535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59536       };
59537     }
59538   }
59539   jresult = result;
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59545   unsigned int jresult ;
59546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59547   Dali::TouchEvent *arg2 = 0 ;
59548   bool result;
59549
59550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59551   arg2 = (Dali::TouchEvent *)jarg2;
59552   if (!arg2) {
59553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59554     return 0;
59555   }
59556   {
59557     try {
59558       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
59559     } catch (std::out_of_range& e) {
59560       {
59561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59562       };
59563     } catch (std::exception& e) {
59564       {
59565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59566       };
59567     } catch (...) {
59568       {
59569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59570       };
59571     }
59572   }
59573   jresult = result;
59574   return jresult;
59575 }
59576
59577
59578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
59579   unsigned int jresult ;
59580   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59581   bool arg2 ;
59582   bool result;
59583
59584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59585   arg2 = jarg2 ? true : false;
59586   {
59587     try {
59588       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
59589     } catch (std::out_of_range& e) {
59590       {
59591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59592       };
59593     } catch (std::exception& e) {
59594       {
59595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59596       };
59597     } catch (...) {
59598       {
59599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59600       };
59601     }
59602   }
59603   jresult = result;
59604   return jresult;
59605 }
59606
59607
59608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
59609   unsigned int jresult ;
59610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59611   bool arg2 ;
59612   bool result;
59613
59614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59615   arg2 = jarg2 ? true : false;
59616   {
59617     try {
59618       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
59619     } catch (std::out_of_range& e) {
59620       {
59621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (std::exception& e) {
59624       {
59625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59626       };
59627     } catch (...) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59630       };
59631     }
59632   }
59633   jresult = result;
59634   return jresult;
59635 }
59636
59637
59638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
59639   unsigned int jresult ;
59640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59641   bool result;
59642
59643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59644   {
59645     try {
59646       result = (bool)(arg1)->OnAccessibilityZoom();
59647     } catch (std::out_of_range& e) {
59648       {
59649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59650       };
59651     } catch (std::exception& e) {
59652       {
59653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59654       };
59655     } catch (...) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59658       };
59659     }
59660   }
59661   jresult = result;
59662   return jresult;
59663 }
59664
59665
59666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
59667   unsigned int jresult ;
59668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59669   bool result;
59670
59671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59672   {
59673     try {
59674       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
59675     } catch (std::out_of_range& e) {
59676       {
59677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59678       };
59679     } catch (std::exception& e) {
59680       {
59681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59682       };
59683     } catch (...) {
59684       {
59685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59686       };
59687     }
59688   }
59689   jresult = result;
59690   return jresult;
59691 }
59692
59693
59694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
59695   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59696
59697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59698   {
59699     try {
59700       (arg1)->OnKeyInputFocusGained();
59701     } catch (std::out_of_range& e) {
59702       {
59703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59704       };
59705     } catch (std::exception& e) {
59706       {
59707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59708       };
59709     } catch (...) {
59710       {
59711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59712       };
59713     }
59714   }
59715 }
59716
59717
59718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
59719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59720
59721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59722   {
59723     try {
59724       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
59725     } catch (std::out_of_range& e) {
59726       {
59727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59728       };
59729     } catch (std::exception& e) {
59730       {
59731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59732       };
59733     } catch (...) {
59734       {
59735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59736       };
59737     }
59738   }
59739 }
59740
59741
59742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
59743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59744
59745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59746   {
59747     try {
59748       (arg1)->OnKeyInputFocusLost();
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59756       };
59757     } catch (...) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59760       };
59761     }
59762   }
59763 }
59764
59765
59766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
59767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59768
59769   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59770   {
59771     try {
59772       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
59773     } catch (std::out_of_range& e) {
59774       {
59775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59776       };
59777     } catch (std::exception& e) {
59778       {
59779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59780       };
59781     } catch (...) {
59782       {
59783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59784       };
59785     }
59786   }
59787 }
59788
59789
59790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59791   void * jresult ;
59792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59793   Dali::Actor arg2 ;
59794   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59795   bool arg4 ;
59796   Dali::Actor *argp2 ;
59797   Dali::Actor result;
59798
59799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59800   argp2 = (Dali::Actor *)jarg2;
59801   if (!argp2) {
59802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59803     return 0;
59804   }
59805   arg2 = *argp2;
59806   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59807   arg4 = jarg4 ? true : false;
59808   {
59809     try {
59810       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59811     } catch (std::out_of_range& e) {
59812       {
59813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (std::exception& e) {
59816       {
59817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59818       };
59819     } catch (...) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59822       };
59823     }
59824   }
59825   jresult = new Dali::Actor((const Dali::Actor &)result);
59826   return jresult;
59827 }
59828
59829
59830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
59831   void * jresult ;
59832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59833   Dali::Actor arg2 ;
59834   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
59835   bool arg4 ;
59836   Dali::Actor *argp2 ;
59837   Dali::Actor result;
59838
59839   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59840   argp2 = (Dali::Actor *)jarg2;
59841   if (!argp2) {
59842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59843     return 0;
59844   }
59845   arg2 = *argp2;
59846   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
59847   arg4 = jarg4 ? true : false;
59848   {
59849     try {
59850       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
59851     } catch (std::out_of_range& e) {
59852       {
59853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (std::exception& e) {
59856       {
59857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (...) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59862       };
59863     }
59864   }
59865   jresult = new Dali::Actor((const Dali::Actor &)result);
59866   return jresult;
59867 }
59868
59869
59870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
59871   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59872   Dali::Actor arg2 ;
59873   Dali::Actor *argp2 ;
59874
59875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59876   argp2 = (Dali::Actor *)jarg2;
59877   if (!argp2) {
59878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59879     return ;
59880   }
59881   arg2 = *argp2;
59882   {
59883     try {
59884       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
59885     } catch (std::out_of_range& e) {
59886       {
59887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59888       };
59889     } catch (std::exception& e) {
59890       {
59891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59892       };
59893     } catch (...) {
59894       {
59895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59896       };
59897     }
59898   }
59899 }
59900
59901
59902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59904   Dali::Actor arg2 ;
59905   Dali::Actor *argp2 ;
59906
59907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59908   argp2 = (Dali::Actor *)jarg2;
59909   if (!argp2) {
59910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59911     return ;
59912   }
59913   arg2 = *argp2;
59914   {
59915     try {
59916       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
59917     } catch (std::out_of_range& e) {
59918       {
59919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59920       };
59921     } catch (std::exception& e) {
59922       {
59923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59924       };
59925     } catch (...) {
59926       {
59927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59928       };
59929     }
59930   }
59931 }
59932
59933
59934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
59935   unsigned int jresult ;
59936   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59937   bool result;
59938
59939   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59940   {
59941     try {
59942       result = (bool)(arg1)->OnKeyboardEnter();
59943     } catch (std::out_of_range& e) {
59944       {
59945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59946       };
59947     } catch (std::exception& e) {
59948       {
59949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59950       };
59951     } catch (...) {
59952       {
59953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59954       };
59955     }
59956   }
59957   jresult = result;
59958   return jresult;
59959 }
59960
59961
59962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
59963   unsigned int jresult ;
59964   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59965   bool result;
59966
59967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59968   {
59969     try {
59970       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
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 = result;
59986   return jresult;
59987 }
59988
59989
59990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
59991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59992   Dali::PinchGesture *arg2 = 0 ;
59993
59994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59995   arg2 = (Dali::PinchGesture *)jarg2;
59996   if (!arg2) {
59997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
59998     return ;
59999   }
60000   {
60001     try {
60002       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
60003     } catch (std::out_of_range& e) {
60004       {
60005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60006       };
60007     } catch (std::exception& e) {
60008       {
60009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60010       };
60011     } catch (...) {
60012       {
60013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60014       };
60015     }
60016   }
60017 }
60018
60019
60020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60022   Dali::PinchGesture *arg2 = 0 ;
60023
60024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60025   arg2 = (Dali::PinchGesture *)jarg2;
60026   if (!arg2) {
60027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
60028     return ;
60029   }
60030   {
60031     try {
60032       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
60033     } catch (std::out_of_range& e) {
60034       {
60035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60036       };
60037     } catch (std::exception& e) {
60038       {
60039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60040       };
60041     } catch (...) {
60042       {
60043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60044       };
60045     }
60046   }
60047 }
60048
60049
60050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
60051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60052   Dali::PanGesture *arg2 = 0 ;
60053
60054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60055   arg2 = (Dali::PanGesture *)jarg2;
60056   if (!arg2) {
60057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
60058     return ;
60059   }
60060   {
60061     try {
60062       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
60063     } catch (std::out_of_range& e) {
60064       {
60065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60066       };
60067     } catch (std::exception& e) {
60068       {
60069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60070       };
60071     } catch (...) {
60072       {
60073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60074       };
60075     }
60076   }
60077 }
60078
60079
60080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60082   Dali::PanGesture *arg2 = 0 ;
60083
60084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60085   arg2 = (Dali::PanGesture *)jarg2;
60086   if (!arg2) {
60087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
60088     return ;
60089   }
60090   {
60091     try {
60092       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60100       };
60101     } catch (...) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60104       };
60105     }
60106   }
60107 }
60108
60109
60110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
60111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60112   Dali::TapGesture *arg2 = 0 ;
60113
60114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60115   arg2 = (Dali::TapGesture *)jarg2;
60116   if (!arg2) {
60117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
60118     return ;
60119   }
60120   {
60121     try {
60122       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
60123     } catch (std::out_of_range& e) {
60124       {
60125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60126       };
60127     } catch (std::exception& e) {
60128       {
60129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60130       };
60131     } catch (...) {
60132       {
60133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60134       };
60135     }
60136   }
60137 }
60138
60139
60140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60142   Dali::TapGesture *arg2 = 0 ;
60143
60144   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60145   arg2 = (Dali::TapGesture *)jarg2;
60146   if (!arg2) {
60147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
60148     return ;
60149   }
60150   {
60151     try {
60152       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
60153     } catch (std::out_of_range& e) {
60154       {
60155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60156       };
60157     } catch (std::exception& e) {
60158       {
60159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60160       };
60161     } catch (...) {
60162       {
60163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60164       };
60165     }
60166   }
60167 }
60168
60169
60170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
60171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60172   Dali::LongPressGesture *arg2 = 0 ;
60173
60174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60175   arg2 = (Dali::LongPressGesture *)jarg2;
60176   if (!arg2) {
60177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60178     return ;
60179   }
60180   {
60181     try {
60182       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
60183     } catch (std::out_of_range& e) {
60184       {
60185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60186       };
60187     } catch (std::exception& e) {
60188       {
60189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60190       };
60191     } catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60194       };
60195     }
60196   }
60197 }
60198
60199
60200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60202   Dali::LongPressGesture *arg2 = 0 ;
60203
60204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60205   arg2 = (Dali::LongPressGesture *)jarg2;
60206   if (!arg2) {
60207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
60208     return ;
60209   }
60210   {
60211     try {
60212       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
60213     } catch (std::out_of_range& e) {
60214       {
60215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60216       };
60217     } catch (std::exception& e) {
60218       {
60219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60220       };
60221     } catch (...) {
60222       {
60223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60224       };
60225     }
60226   }
60227 }
60228
60229
60230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
60231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60232   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60233   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60234
60235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60236   arg2 = (Dali::SlotObserver *)jarg2;
60237   arg3 = (Dali::CallbackBase *)jarg3;
60238   {
60239     try {
60240       (arg1)->SignalConnected(arg2,arg3);
60241     } catch (std::out_of_range& e) {
60242       {
60243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60244       };
60245     } catch (std::exception& e) {
60246       {
60247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60248       };
60249     } catch (...) {
60250       {
60251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60252       };
60253     }
60254   }
60255 }
60256
60257
60258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60260   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60261   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60262
60263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60264   arg2 = (Dali::SlotObserver *)jarg2;
60265   arg3 = (Dali::CallbackBase *)jarg3;
60266   {
60267     try {
60268       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60280       };
60281     }
60282   }
60283 }
60284
60285
60286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
60287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60288   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60289   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60290
60291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60292   arg2 = (Dali::SlotObserver *)jarg2;
60293   arg3 = (Dali::CallbackBase *)jarg3;
60294   {
60295     try {
60296       (arg1)->SignalDisconnected(arg2,arg3);
60297     } catch (std::out_of_range& e) {
60298       {
60299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60300       };
60301     } catch (std::exception& e) {
60302       {
60303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60304       };
60305     } catch (...) {
60306       {
60307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60308       };
60309     }
60310   }
60311 }
60312
60313
60314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60316   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
60317   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
60318
60319   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60320   arg2 = (Dali::SlotObserver *)jarg2;
60321   arg3 = (Dali::CallbackBase *)jarg3;
60322   {
60323     try {
60324       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
60325     } catch (std::out_of_range& e) {
60326       {
60327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60328       };
60329     } catch (std::exception& e) {
60330       {
60331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60332       };
60333     } catch (...) {
60334       {
60335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60336       };
60337     }
60338   }
60339 }
60340
60341
60342 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) {
60343   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
60344   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
60345   if (director) {
60346     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);
60347   }
60348 }
60349
60350
60351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
60352   void * jresult ;
60353   Dali::Toolkit::Control *arg1 = 0 ;
60354   Dali::Toolkit::Internal::Control *result = 0 ;
60355
60356   arg1 = (Dali::Toolkit::Control *)jarg1;
60357   if (!arg1) {
60358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
60359     return 0;
60360   }
60361   {
60362     try {
60363       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
60364     } catch (std::out_of_range& e) {
60365       {
60366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60367       };
60368     } catch (std::exception& e) {
60369       {
60370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60371       };
60372     } catch (...) {
60373       {
60374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60375       };
60376     }
60377   }
60378   jresult = (void *)result;
60379   return jresult;
60380 }
60381
60382
60383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
60384   int jresult ;
60385   int result;
60386
60387   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
60388   jresult = (int)result;
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
60394   int jresult ;
60395   int result;
60396
60397   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
60398   jresult = (int)result;
60399   return jresult;
60400 }
60401
60402
60403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
60404   int jresult ;
60405   int result;
60406
60407   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
60408   jresult = (int)result;
60409   return jresult;
60410 }
60411
60412
60413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
60414   int jresult ;
60415   int result;
60416
60417   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
60418   jresult = (int)result;
60419   return jresult;
60420 }
60421
60422
60423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
60424   int jresult ;
60425   int result;
60426
60427   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
60428   jresult = (int)result;
60429   return jresult;
60430 }
60431
60432
60433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
60434   void * jresult ;
60435   Dali::Toolkit::Control::Property *result = 0 ;
60436
60437   {
60438     try {
60439       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
60440     } catch (std::out_of_range& e) {
60441       {
60442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60443       };
60444     } catch (std::exception& e) {
60445       {
60446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60447       };
60448     } catch (...) {
60449       {
60450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60451       };
60452     }
60453   }
60454   jresult = (void *)result;
60455   return jresult;
60456 }
60457
60458
60459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
60460   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
60461
60462   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
60463   {
60464     try {
60465       delete arg1;
60466     } catch (std::out_of_range& e) {
60467       {
60468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60469       };
60470     } catch (std::exception& e) {
60471       {
60472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60473       };
60474     } catch (...) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60477       };
60478     }
60479   }
60480 }
60481
60482
60483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
60484   void * jresult ;
60485   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
60486
60487   {
60488     try {
60489       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
60490     } catch (std::out_of_range& e) {
60491       {
60492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60493       };
60494     } catch (std::exception& e) {
60495       {
60496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60497       };
60498     } catch (...) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60501       };
60502     }
60503   }
60504   jresult = (void *)result;
60505   return jresult;
60506 }
60507
60508
60509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
60510   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
60511
60512   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
60513   {
60514     try {
60515       delete arg1;
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60523       };
60524     } catch (...) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60527       };
60528     }
60529   }
60530 }
60531
60532
60533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
60534   void * jresult ;
60535   Dali::Toolkit::Control result;
60536
60537   {
60538     try {
60539       result = Dali::Toolkit::Control::New();
60540     } catch (std::out_of_range& e) {
60541       {
60542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60543       };
60544     } catch (std::exception& e) {
60545       {
60546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (...) {
60549       {
60550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60551       };
60552     }
60553   }
60554   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60555   return jresult;
60556 }
60557
60558
60559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
60560   void * jresult ;
60561   Dali::Toolkit::Control *result = 0 ;
60562
60563   {
60564     try {
60565       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
60566     } catch (std::out_of_range& e) {
60567       {
60568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60569       };
60570     } catch (std::exception& e) {
60571       {
60572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60573       };
60574     } catch (...) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60577       };
60578     }
60579   }
60580   jresult = (void *)result;
60581   return jresult;
60582 }
60583
60584
60585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
60586   void * jresult ;
60587   Dali::Toolkit::Control *arg1 = 0 ;
60588   Dali::Toolkit::Control *result = 0 ;
60589
60590   arg1 = (Dali::Toolkit::Control *)jarg1;
60591   if (!arg1) {
60592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60593     return 0;
60594   }
60595   {
60596     try {
60597       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
60598     } catch (std::out_of_range& e) {
60599       {
60600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60601       };
60602     } catch (std::exception& e) {
60603       {
60604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60605       };
60606     } catch (...) {
60607       {
60608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60609       };
60610     }
60611   }
60612   jresult = (void *)result;
60613   return jresult;
60614 }
60615
60616
60617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
60618   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60619
60620   arg1 = (Dali::Toolkit::Control *)jarg1;
60621   {
60622     try {
60623       delete arg1;
60624     } catch (std::out_of_range& e) {
60625       {
60626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60627       };
60628     } catch (std::exception& e) {
60629       {
60630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60631       };
60632     } catch (...) {
60633       {
60634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60635       };
60636     }
60637   }
60638 }
60639
60640
60641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
60642   void * jresult ;
60643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60644   Dali::Toolkit::Control *arg2 = 0 ;
60645   Dali::Toolkit::Control *result = 0 ;
60646
60647   arg1 = (Dali::Toolkit::Control *)jarg1;
60648   arg2 = (Dali::Toolkit::Control *)jarg2;
60649   if (!arg2) {
60650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
60651     return 0;
60652   }
60653   {
60654     try {
60655       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
60656     } catch (std::out_of_range& e) {
60657       {
60658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (std::exception& e) {
60661       {
60662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60667       };
60668     }
60669   }
60670   jresult = (void *)result;
60671   return jresult;
60672 }
60673
60674
60675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
60676   void * jresult ;
60677   Dali::BaseHandle arg1 ;
60678   Dali::BaseHandle *argp1 ;
60679   Dali::Toolkit::Control result;
60680
60681   argp1 = (Dali::BaseHandle *)jarg1;
60682   if (!argp1) {
60683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60684     return 0;
60685   }
60686   arg1 = *argp1;
60687   {
60688     try {
60689       result = Dali::Toolkit::Control::DownCast(arg1);
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60697       };
60698     } catch (...) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60701       };
60702     }
60703   }
60704   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60705   return jresult;
60706 }
60707
60708
60709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
60710   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60711
60712   arg1 = (Dali::Toolkit::Control *)jarg1;
60713   {
60714     try {
60715       (arg1)->SetKeyInputFocus();
60716     } catch (std::out_of_range& e) {
60717       {
60718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60719       };
60720     } catch (std::exception& e) {
60721       {
60722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60723       };
60724     } catch (...) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60727       };
60728     }
60729   }
60730 }
60731
60732
60733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
60734   unsigned int jresult ;
60735   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60736   bool result;
60737
60738   arg1 = (Dali::Toolkit::Control *)jarg1;
60739   {
60740     try {
60741       result = (bool)(arg1)->HasKeyInputFocus();
60742     } catch (std::out_of_range& e) {
60743       {
60744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60745       };
60746     } catch (std::exception& e) {
60747       {
60748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (...) {
60751       {
60752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60753       };
60754     }
60755   }
60756   jresult = result;
60757   return jresult;
60758 }
60759
60760
60761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
60762   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60763
60764   arg1 = (Dali::Toolkit::Control *)jarg1;
60765   {
60766     try {
60767       (arg1)->ClearKeyInputFocus();
60768     } catch (std::out_of_range& e) {
60769       {
60770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60771       };
60772     } catch (std::exception& e) {
60773       {
60774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60775       };
60776     } catch (...) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60779       };
60780     }
60781   }
60782 }
60783
60784
60785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
60786   void * jresult ;
60787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60788   Dali::PinchGestureDetector result;
60789
60790   arg1 = (Dali::Toolkit::Control *)jarg1;
60791   {
60792     try {
60793       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
60794     } catch (std::out_of_range& e) {
60795       {
60796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60797       };
60798     } catch (std::exception& e) {
60799       {
60800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60801       };
60802     } catch (...) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60805       };
60806     }
60807   }
60808   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60809   return jresult;
60810 }
60811
60812
60813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
60814   void * jresult ;
60815   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60816   Dali::PanGestureDetector result;
60817
60818   arg1 = (Dali::Toolkit::Control *)jarg1;
60819   {
60820     try {
60821       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
60822     } catch (std::out_of_range& e) {
60823       {
60824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60825       };
60826     } catch (std::exception& e) {
60827       {
60828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (...) {
60831       {
60832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60833       };
60834     }
60835   }
60836   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60837   return jresult;
60838 }
60839
60840
60841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
60842   void * jresult ;
60843   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60844   Dali::TapGestureDetector result;
60845
60846   arg1 = (Dali::Toolkit::Control *)jarg1;
60847   {
60848     try {
60849       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
60850     } catch (std::out_of_range& e) {
60851       {
60852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60853       };
60854     } catch (std::exception& e) {
60855       {
60856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (...) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60861       };
60862     }
60863   }
60864   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60865   return jresult;
60866 }
60867
60868
60869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
60870   void * jresult ;
60871   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60872   Dali::LongPressGestureDetector result;
60873
60874   arg1 = (Dali::Toolkit::Control *)jarg1;
60875   {
60876     try {
60877       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
60878     } catch (std::out_of_range& e) {
60879       {
60880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60881       };
60882     } catch (std::exception& e) {
60883       {
60884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60885       };
60886     } catch (...) {
60887       {
60888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60889       };
60890     }
60891   }
60892   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60893   return jresult;
60894 }
60895
60896
60897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
60898   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60899   std::string *arg2 = 0 ;
60900
60901   arg1 = (Dali::Toolkit::Control *)jarg1;
60902   if (!jarg2) {
60903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60904     return ;
60905   }
60906   std::string arg2_str(jarg2);
60907   arg2 = &arg2_str;
60908   {
60909     try {
60910       (arg1)->SetStyleName((std::string const &)*arg2);
60911     } catch (std::out_of_range& e) {
60912       {
60913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60914       };
60915     } catch (std::exception& e) {
60916       {
60917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60918       };
60919     } catch (...) {
60920       {
60921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60922       };
60923     }
60924   }
60925
60926   //argout typemap for const std::string&
60927
60928 }
60929
60930
60931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
60932   char * jresult ;
60933   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60934   std::string *result = 0 ;
60935
60936   arg1 = (Dali::Toolkit::Control *)jarg1;
60937   {
60938     try {
60939       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
60940     } catch (std::out_of_range& e) {
60941       {
60942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60943       };
60944     } catch (std::exception& e) {
60945       {
60946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60947       };
60948     } catch (...) {
60949       {
60950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60951       };
60952     }
60953   }
60954   jresult = SWIG_csharp_string_callback(result->c_str());
60955   return jresult;
60956 }
60957
60958
60959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
60960   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60961   Dali::Vector4 *arg2 = 0 ;
60962
60963   arg1 = (Dali::Toolkit::Control *)jarg1;
60964   arg2 = (Dali::Vector4 *)jarg2;
60965   if (!arg2) {
60966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60967     return ;
60968   }
60969   {
60970     try {
60971       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60972     } catch (std::out_of_range& e) {
60973       {
60974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60975       };
60976     } catch (std::exception& e) {
60977       {
60978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60979       };
60980     } catch (...) {
60981       {
60982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60983       };
60984     }
60985   }
60986 }
60987
60988
60989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
60990   void * jresult ;
60991   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
60992   Dali::Vector4 result;
60993
60994   arg1 = (Dali::Toolkit::Control *)jarg1;
60995   {
60996     try {
60997       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
60998     } catch (std::out_of_range& e) {
60999       {
61000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61001       };
61002     } catch (std::exception& e) {
61003       {
61004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61005       };
61006     } catch (...) {
61007       {
61008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61009       };
61010     }
61011   }
61012   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
61013   return jresult;
61014 }
61015
61016
61017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
61018   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61019   Dali::Image arg2 ;
61020   Dali::Image *argp2 ;
61021
61022   arg1 = (Dali::Toolkit::Control *)jarg1;
61023   argp2 = (Dali::Image *)jarg2;
61024   if (!argp2) {
61025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
61026     return ;
61027   }
61028   arg2 = *argp2;
61029   {
61030     try {
61031       (arg1)->SetBackgroundImage(arg2);
61032     } catch (std::out_of_range& e) {
61033       {
61034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61035       };
61036     } catch (std::exception& e) {
61037       {
61038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61039       };
61040     } catch (...) {
61041       {
61042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61043       };
61044     }
61045   }
61046 }
61047
61048
61049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
61050   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61051
61052   arg1 = (Dali::Toolkit::Control *)jarg1;
61053   {
61054     try {
61055       (arg1)->ClearBackground();
61056     } catch (std::out_of_range& e) {
61057       {
61058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61059       };
61060     } catch (std::exception& e) {
61061       {
61062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61063       };
61064     } catch (...) {
61065       {
61066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61067       };
61068     }
61069   }
61070 }
61071
61072
61073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
61074   void * jresult ;
61075   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61076   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
61077
61078   arg1 = (Dali::Toolkit::Control *)jarg1;
61079   {
61080     try {
61081       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (...) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61093       };
61094     }
61095   }
61096   jresult = (void *)result;
61097   return jresult;
61098 }
61099
61100
61101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
61102   void * jresult ;
61103   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61104   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61105
61106   arg1 = (Dali::Toolkit::Control *)jarg1;
61107   {
61108     try {
61109       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
61110     } catch (std::out_of_range& e) {
61111       {
61112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61113       };
61114     } catch (std::exception& e) {
61115       {
61116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61117       };
61118     } catch (...) {
61119       {
61120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61121       };
61122     }
61123   }
61124   jresult = (void *)result;
61125   return jresult;
61126 }
61127
61128
61129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
61130   void * jresult ;
61131   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61132   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61133
61134   arg1 = (Dali::Toolkit::Control *)jarg1;
61135   {
61136     try {
61137       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
61138     } catch (std::out_of_range& e) {
61139       {
61140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (std::exception& e) {
61143       {
61144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61145       };
61146     } catch (...) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61149       };
61150     }
61151   }
61152   jresult = (void *)result;
61153   return jresult;
61154 }
61155
61156
61157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
61158   void * jresult ;
61159   Dali::Toolkit::Internal::Control *arg1 = 0 ;
61160   Dali::Toolkit::Control *result = 0 ;
61161
61162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61163   if (!arg1) {
61164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
61165     return 0;
61166   }
61167   {
61168     try {
61169       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
61170     } catch (std::out_of_range& e) {
61171       {
61172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61173       };
61174     } catch (std::exception& e) {
61175       {
61176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61177       };
61178     } catch (...) {
61179       {
61180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61181       };
61182     }
61183   }
61184   jresult = (void *)result;
61185   return jresult;
61186 }
61187
61188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
61189 {
61190   void * jresult;
61191   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
61192   arg1 = (Dali::Toolkit::Control *)jarg1;
61193
61194   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
61195
61196   Dali::Toolkit::TransitionData *arg2 = 0 ;
61197   Dali::Animation result;
61198
61199   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
61200   if (!arg2) {
61201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
61202     return 0;
61203   }
61204   {
61205     try {
61206       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
61207     } catch (std::out_of_range& e) {
61208       {
61209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61210       };
61211     } catch (std::exception& e) {
61212       {
61213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61214       };
61215     } catch (...) {
61216       {
61217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61218       };
61219     }
61220   }
61221   jresult = new Dali::Animation((const Dali::Animation &)result);
61222   return jresult;
61223 }
61224
61225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
61226   void * jresult ;
61227   Dali::Toolkit::Control *arg1 = 0 ;
61228   Dali::Toolkit::DevelControl::ResourceReadySignalType *result = 0 ;
61229
61230   arg1 = (Dali::Toolkit::Control *)jarg1;
61231   if (!arg1) {
61232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
61233     return 0;
61234   }
61235   {
61236     try {
61237       result = (Dali::Toolkit::DevelControl::ResourceReadySignalType *) &Dali::Toolkit::DevelControl::ResourceReadySignal(*arg1);
61238     } catch (std::out_of_range& e) {
61239       {
61240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61241       };
61242     } catch (std::exception& e) {
61243       {
61244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61245       };
61246     } catch (...) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61249       };
61250     }
61251   }
61252   jresult = (void *)result;
61253   return jresult;
61254 }
61255
61256
61257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
61258   unsigned int jresult ;
61259   Dali::Toolkit::Control *arg1 = 0 ;
61260   bool result;
61261
61262   arg1 = (Dali::Toolkit::Control *)jarg1;
61263   if (!arg1) {
61264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
61265     return 0;
61266   }
61267   {
61268     try {
61269       result = (bool)Dali::Toolkit::DevelControl::IsResourceReady((Dali::Toolkit::Control const &)*arg1);
61270     } catch (std::out_of_range& e) {
61271       {
61272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61273       };
61274     } catch (std::exception& e) {
61275       {
61276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61277       };
61278     } catch (...) {
61279       {
61280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61281       };
61282     }
61283   }
61284   jresult = result;
61285   return jresult;
61286 }
61287
61288
61289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
61290   void * jresult ;
61291   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
61292
61293   {
61294     try {
61295       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
61296     } catch (std::out_of_range& e) {
61297       {
61298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61299       };
61300     } catch (std::exception& e) {
61301       {
61302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61303       };
61304     } catch (...) {
61305       {
61306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61307       };
61308     }
61309   }
61310   jresult = (void *)result;
61311   return jresult;
61312 }
61313
61314
61315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
61316   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61317
61318   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61319   {
61320     try {
61321       delete arg1;
61322     } catch (std::out_of_range& e) {
61323       {
61324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61325       };
61326     } catch (std::exception& e) {
61327       {
61328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61329       };
61330     } catch (...) {
61331       {
61332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61333       };
61334     }
61335   }
61336 }
61337
61338
61339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
61340   void * jresult ;
61341   Dali::Toolkit::KeyInputFocusManager result;
61342
61343   {
61344     try {
61345       result = Dali::Toolkit::KeyInputFocusManager::Get();
61346     } catch (std::out_of_range& e) {
61347       {
61348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61349       };
61350     } catch (std::exception& e) {
61351       {
61352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (...) {
61355       {
61356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61357       };
61358     }
61359   }
61360   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
61361   return jresult;
61362 }
61363
61364
61365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
61366   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61367   Dali::Toolkit::Control arg2 ;
61368   Dali::Toolkit::Control *argp2 ;
61369
61370   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61371   argp2 = (Dali::Toolkit::Control *)jarg2;
61372   if (!argp2) {
61373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61374     return ;
61375   }
61376   arg2 = *argp2;
61377   {
61378     try {
61379       (arg1)->SetFocus(arg2);
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61387       };
61388     } catch (...) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61391       };
61392     }
61393   }
61394 }
61395
61396
61397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
61398   void * jresult ;
61399   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61400   Dali::Toolkit::Control result;
61401
61402   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61403   {
61404     try {
61405       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
61406     } catch (std::out_of_range& e) {
61407       {
61408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61409       };
61410     } catch (std::exception& e) {
61411       {
61412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (...) {
61415       {
61416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61417       };
61418     }
61419   }
61420   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61421   return jresult;
61422 }
61423
61424
61425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
61426   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61427   Dali::Toolkit::Control arg2 ;
61428   Dali::Toolkit::Control *argp2 ;
61429
61430   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61431   argp2 = (Dali::Toolkit::Control *)jarg2;
61432   if (!argp2) {
61433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
61434     return ;
61435   }
61436   arg2 = *argp2;
61437   {
61438     try {
61439       (arg1)->RemoveFocus(arg2);
61440     } catch (std::out_of_range& e) {
61441       {
61442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61443       };
61444     } catch (std::exception& e) {
61445       {
61446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61447       };
61448     } catch (...) {
61449       {
61450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61451       };
61452     }
61453   }
61454 }
61455
61456
61457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
61458   void * jresult ;
61459   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
61460   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
61461
61462   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
61463   {
61464     try {
61465       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
61466     } catch (std::out_of_range& e) {
61467       {
61468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61469       };
61470     } catch (std::exception& e) {
61471       {
61472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61473       };
61474     } catch (...) {
61475       {
61476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61477       };
61478     }
61479   }
61480   jresult = (void *)result;
61481   return jresult;
61482 }
61483
61484
61485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
61486   void * jresult ;
61487   Dali::Toolkit::Alignment::Padding *result = 0 ;
61488
61489   {
61490     try {
61491       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
61492     } catch (std::out_of_range& e) {
61493       {
61494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61495       };
61496     } catch (std::exception& e) {
61497       {
61498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61499       };
61500     } catch (...) {
61501       {
61502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61503       };
61504     }
61505   }
61506   jresult = (void *)result;
61507   return jresult;
61508 }
61509
61510
61511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
61512   void * jresult ;
61513   float arg1 ;
61514   float arg2 ;
61515   float arg3 ;
61516   float arg4 ;
61517   Dali::Toolkit::Alignment::Padding *result = 0 ;
61518
61519   arg1 = (float)jarg1;
61520   arg2 = (float)jarg2;
61521   arg3 = (float)jarg3;
61522   arg4 = (float)jarg4;
61523   {
61524     try {
61525       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
61526     } catch (std::out_of_range& e) {
61527       {
61528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61529       };
61530     } catch (std::exception& e) {
61531       {
61532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61533       };
61534     } catch (...) {
61535       {
61536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61537       };
61538     }
61539   }
61540   jresult = (void *)result;
61541   return jresult;
61542 }
61543
61544
61545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
61546   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61547   float arg2 ;
61548
61549   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61550   arg2 = (float)jarg2;
61551   if (arg1) (arg1)->left = arg2;
61552 }
61553
61554
61555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
61556   float jresult ;
61557   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61558   float result;
61559
61560   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61561   result = (float) ((arg1)->left);
61562   jresult = result;
61563   return jresult;
61564 }
61565
61566
61567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
61568   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61569   float arg2 ;
61570
61571   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61572   arg2 = (float)jarg2;
61573   if (arg1) (arg1)->right = arg2;
61574 }
61575
61576
61577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
61578   float jresult ;
61579   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61580   float result;
61581
61582   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61583   result = (float) ((arg1)->right);
61584   jresult = result;
61585   return jresult;
61586 }
61587
61588
61589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
61590   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61591   float arg2 ;
61592
61593   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61594   arg2 = (float)jarg2;
61595   if (arg1) (arg1)->top = arg2;
61596 }
61597
61598
61599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
61600   float jresult ;
61601   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61602   float result;
61603
61604   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61605   result = (float) ((arg1)->top);
61606   jresult = result;
61607   return jresult;
61608 }
61609
61610
61611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
61612   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61613   float arg2 ;
61614
61615   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61616   arg2 = (float)jarg2;
61617   if (arg1) (arg1)->bottom = arg2;
61618 }
61619
61620
61621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
61622   float jresult ;
61623   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61624   float result;
61625
61626   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61627   result = (float) ((arg1)->bottom);
61628   jresult = result;
61629   return jresult;
61630 }
61631
61632
61633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
61634   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
61635
61636   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
61637   {
61638     try {
61639       delete arg1;
61640     } catch (std::out_of_range& e) {
61641       {
61642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61643       };
61644     } catch (std::exception& e) {
61645       {
61646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61647       };
61648     } catch (...) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61651       };
61652     }
61653   }
61654 }
61655
61656
61657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
61658   void * jresult ;
61659   Dali::Toolkit::Alignment *result = 0 ;
61660
61661   {
61662     try {
61663       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
61664     } catch (std::out_of_range& e) {
61665       {
61666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (std::exception& e) {
61669       {
61670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (...) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61675       };
61676     }
61677   }
61678   jresult = (void *)result;
61679   return jresult;
61680 }
61681
61682
61683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
61684   void * jresult ;
61685   Dali::Toolkit::Alignment::Type arg1 ;
61686   Dali::Toolkit::Alignment::Type arg2 ;
61687   Dali::Toolkit::Alignment result;
61688
61689   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61690   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61691   {
61692     try {
61693       result = Dali::Toolkit::Alignment::New(arg1,arg2);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (...) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61705       };
61706     }
61707   }
61708   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61709   return jresult;
61710 }
61711
61712
61713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
61714   void * jresult ;
61715   Dali::Toolkit::Alignment::Type arg1 ;
61716   Dali::Toolkit::Alignment result;
61717
61718   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
61719   {
61720     try {
61721       result = Dali::Toolkit::Alignment::New(arg1);
61722     } catch (std::out_of_range& e) {
61723       {
61724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61725       };
61726     } catch (std::exception& e) {
61727       {
61728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61729       };
61730     } catch (...) {
61731       {
61732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61733       };
61734     }
61735   }
61736   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61737   return jresult;
61738 }
61739
61740
61741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
61742   void * jresult ;
61743   Dali::Toolkit::Alignment result;
61744
61745   {
61746     try {
61747       result = Dali::Toolkit::Alignment::New();
61748     } catch (std::out_of_range& e) {
61749       {
61750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61751       };
61752     } catch (std::exception& e) {
61753       {
61754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61755       };
61756     } catch (...) {
61757       {
61758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61759       };
61760     }
61761   }
61762   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61763   return jresult;
61764 }
61765
61766
61767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
61768   void * jresult ;
61769   Dali::Toolkit::Alignment *arg1 = 0 ;
61770   Dali::Toolkit::Alignment *result = 0 ;
61771
61772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61773   if (!arg1) {
61774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
61775     return 0;
61776   }
61777   {
61778     try {
61779       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
61780     } catch (std::out_of_range& e) {
61781       {
61782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61783       };
61784     } catch (std::exception& e) {
61785       {
61786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61787       };
61788     } catch (...) {
61789       {
61790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61791       };
61792     }
61793   }
61794   jresult = (void *)result;
61795   return jresult;
61796 }
61797
61798
61799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
61800   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61801
61802   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61803   {
61804     try {
61805       delete arg1;
61806     } catch (std::out_of_range& e) {
61807       {
61808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61809       };
61810     } catch (std::exception& e) {
61811       {
61812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61813       };
61814     } catch (...) {
61815       {
61816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61817       };
61818     }
61819   }
61820 }
61821
61822
61823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
61824   void * jresult ;
61825   Dali::BaseHandle arg1 ;
61826   Dali::BaseHandle *argp1 ;
61827   Dali::Toolkit::Alignment result;
61828
61829   argp1 = (Dali::BaseHandle *)jarg1;
61830   if (!argp1) {
61831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61832     return 0;
61833   }
61834   arg1 = *argp1;
61835   {
61836     try {
61837       result = Dali::Toolkit::Alignment::DownCast(arg1);
61838     } catch (std::out_of_range& e) {
61839       {
61840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61841       };
61842     } catch (std::exception& e) {
61843       {
61844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61845       };
61846     } catch (...) {
61847       {
61848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61849       };
61850     }
61851   }
61852   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
61853   return jresult;
61854 }
61855
61856
61857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
61858   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61859   Dali::Toolkit::Alignment::Type arg2 ;
61860
61861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61862   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
61863   {
61864     try {
61865       (arg1)->SetAlignmentType(arg2);
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61873       };
61874     } catch (...) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61877       };
61878     }
61879   }
61880 }
61881
61882
61883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
61884   int jresult ;
61885   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61886   Dali::Toolkit::Alignment::Type result;
61887
61888   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61889   {
61890     try {
61891       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
61892     } catch (std::out_of_range& e) {
61893       {
61894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61895       };
61896     } catch (std::exception& e) {
61897       {
61898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61899       };
61900     } catch (...) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61903       };
61904     }
61905   }
61906   jresult = (int)result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
61912   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61913   Dali::Toolkit::Alignment::Scaling arg2 ;
61914
61915   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61916   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
61917   {
61918     try {
61919       (arg1)->SetScaling(arg2);
61920     } catch (std::out_of_range& e) {
61921       {
61922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61923       };
61924     } catch (std::exception& e) {
61925       {
61926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61927       };
61928     } catch (...) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61931       };
61932     }
61933   }
61934 }
61935
61936
61937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
61938   int jresult ;
61939   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61940   Dali::Toolkit::Alignment::Scaling result;
61941
61942   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61943   {
61944     try {
61945       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
61946     } catch (std::out_of_range& e) {
61947       {
61948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61949       };
61950     } catch (std::exception& e) {
61951       {
61952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61953       };
61954     } catch (...) {
61955       {
61956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61957       };
61958     }
61959   }
61960   jresult = (int)result;
61961   return jresult;
61962 }
61963
61964
61965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
61966   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61967   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
61968
61969   arg1 = (Dali::Toolkit::Alignment *)jarg1;
61970   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
61971   if (!arg2) {
61972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
61973     return ;
61974   }
61975   {
61976     try {
61977       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
61978     } catch (std::out_of_range& e) {
61979       {
61980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61981       };
61982     } catch (std::exception& e) {
61983       {
61984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61985       };
61986     } catch (...) {
61987       {
61988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61989       };
61990     }
61991   }
61992 }
61993
61994
61995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
61996   void * jresult ;
61997   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
61998   Dali::Toolkit::Alignment::Padding *result = 0 ;
61999
62000   arg1 = (Dali::Toolkit::Alignment *)jarg1;
62001   {
62002     try {
62003       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
62004     } catch (std::out_of_range& e) {
62005       {
62006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62007       };
62008     } catch (std::exception& e) {
62009       {
62010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62011       };
62012     } catch (...) {
62013       {
62014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62015       };
62016     }
62017   }
62018   jresult = (void *)result;
62019   return jresult;
62020 }
62021
62022
62023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
62024   void * jresult ;
62025   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
62026   Dali::Toolkit::Alignment *arg2 = 0 ;
62027   Dali::Toolkit::Alignment *result = 0 ;
62028
62029   arg1 = (Dali::Toolkit::Alignment *)jarg1;
62030   arg2 = (Dali::Toolkit::Alignment *)jarg2;
62031   if (!arg2) {
62032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
62033     return 0;
62034   }
62035   {
62036     try {
62037       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
62038     } catch (std::out_of_range& e) {
62039       {
62040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62041       };
62042     } catch (std::exception& e) {
62043       {
62044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62045       };
62046     } catch (...) {
62047       {
62048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62049       };
62050     }
62051   }
62052   jresult = (void *)result;
62053   return jresult;
62054 }
62055
62056
62057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
62058   int jresult ;
62059   int result;
62060
62061   result = (int)Dali::Toolkit::Button::Property::DISABLED;
62062   jresult = (int)result;
62063   return jresult;
62064 }
62065
62066
62067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
62068   int jresult ;
62069   int result;
62070
62071   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
62072   jresult = (int)result;
62073   return jresult;
62074 }
62075
62076
62077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
62078   int jresult ;
62079   int result;
62080
62081   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
62082   jresult = (int)result;
62083   return jresult;
62084 }
62085
62086
62087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
62088   int jresult ;
62089   int result;
62090
62091   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
62092   jresult = (int)result;
62093   return jresult;
62094 }
62095
62096
62097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
62098   int jresult ;
62099   int result;
62100
62101   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
62102   jresult = (int)result;
62103   return jresult;
62104 }
62105
62106
62107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
62108   int jresult ;
62109   int result;
62110
62111   result = (int)Dali::Toolkit::Button::Property::SELECTED;
62112   jresult = (int)result;
62113   return jresult;
62114 }
62115
62116
62117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
62118   int jresult ;
62119   int result;
62120
62121   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
62122   jresult = (int)result;
62123   return jresult;
62124 }
62125
62126
62127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
62128   int jresult ;
62129   int result;
62130
62131   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
62132   jresult = (int)result;
62133   return jresult;
62134 }
62135
62136
62137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
62138   int jresult ;
62139   int result;
62140
62141   result = (int)Dali::Toolkit::Button::Property::LABEL;
62142   jresult = (int)result;
62143   return jresult;
62144 }
62145
62146
62147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
62148   int jresult ;
62149   int result;
62150
62151   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
62152   jresult = (int)result;
62153   return jresult;
62154 }
62155
62156
62157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
62158   void * jresult ;
62159   Dali::Toolkit::Button::Property *result = 0 ;
62160
62161   {
62162     try {
62163       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
62164     } catch (std::out_of_range& e) {
62165       {
62166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62167       };
62168     } catch (std::exception& e) {
62169       {
62170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62171       };
62172     } catch (...) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62175       };
62176     }
62177   }
62178   jresult = (void *)result;
62179   return jresult;
62180 }
62181
62182
62183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
62184   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
62185
62186   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
62187   {
62188     try {
62189       delete arg1;
62190     } catch (std::out_of_range& e) {
62191       {
62192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62193       };
62194     } catch (std::exception& e) {
62195       {
62196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62197       };
62198     } catch (...) {
62199       {
62200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62201       };
62202     }
62203   }
62204 }
62205
62206
62207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
62208   void * jresult ;
62209   Dali::Toolkit::Button *result = 0 ;
62210
62211   {
62212     try {
62213       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
62214     } catch (std::out_of_range& e) {
62215       {
62216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62217       };
62218     } catch (std::exception& e) {
62219       {
62220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62225       };
62226     }
62227   }
62228   jresult = (void *)result;
62229   return jresult;
62230 }
62231
62232
62233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
62234   void * jresult ;
62235   Dali::Toolkit::Button *arg1 = 0 ;
62236   Dali::Toolkit::Button *result = 0 ;
62237
62238   arg1 = (Dali::Toolkit::Button *)jarg1;
62239   if (!arg1) {
62240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62241     return 0;
62242   }
62243   {
62244     try {
62245       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
62246     } catch (std::out_of_range& e) {
62247       {
62248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62249       };
62250     } catch (std::exception& e) {
62251       {
62252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62253       };
62254     } catch (...) {
62255       {
62256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62257       };
62258     }
62259   }
62260   jresult = (void *)result;
62261   return jresult;
62262 }
62263
62264
62265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
62266   void * jresult ;
62267   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62268   Dali::Toolkit::Button *arg2 = 0 ;
62269   Dali::Toolkit::Button *result = 0 ;
62270
62271   arg1 = (Dali::Toolkit::Button *)jarg1;
62272   arg2 = (Dali::Toolkit::Button *)jarg2;
62273   if (!arg2) {
62274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
62275     return 0;
62276   }
62277   {
62278     try {
62279       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
62280     } catch (std::out_of_range& e) {
62281       {
62282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62283       };
62284     } catch (std::exception& e) {
62285       {
62286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62287       };
62288     } catch (...) {
62289       {
62290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62291       };
62292     }
62293   }
62294   jresult = (void *)result;
62295   return jresult;
62296 }
62297
62298
62299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
62300   void * jresult ;
62301   Dali::BaseHandle arg1 ;
62302   Dali::BaseHandle *argp1 ;
62303   Dali::Toolkit::Button result;
62304
62305   argp1 = (Dali::BaseHandle *)jarg1;
62306   if (!argp1) {
62307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62308     return 0;
62309   }
62310   arg1 = *argp1;
62311   {
62312     try {
62313       result = Dali::Toolkit::Button::DownCast(arg1);
62314     } catch (std::out_of_range& e) {
62315       {
62316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62317       };
62318     } catch (std::exception& e) {
62319       {
62320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (...) {
62323       {
62324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62325       };
62326     }
62327   }
62328   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
62329   return jresult;
62330 }
62331
62332
62333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
62334   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62335
62336   arg1 = (Dali::Toolkit::Button *)jarg1;
62337   {
62338     try {
62339       delete arg1;
62340     } catch (std::out_of_range& e) {
62341       {
62342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62343       };
62344     } catch (std::exception& e) {
62345       {
62346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62347       };
62348     } catch (...) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62351       };
62352     }
62353   }
62354 }
62355
62356
62357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
62358   unsigned int jresult ;
62359   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62360   bool result;
62361
62362   arg1 = (Dali::Toolkit::Button *)jarg1;
62363   {
62364     try {
62365       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
62366     } catch (std::out_of_range& e) {
62367       {
62368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62369       };
62370     } catch (std::exception& e) {
62371       {
62372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62373       };
62374     } catch (...) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62377       };
62378     }
62379   }
62380   jresult = result;
62381   return jresult;
62382 }
62383
62384
62385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
62386   unsigned int jresult ;
62387   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62388   bool result;
62389
62390   arg1 = (Dali::Toolkit::Button *)jarg1;
62391   {
62392     try {
62393       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
62394     } catch (std::out_of_range& e) {
62395       {
62396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (std::exception& e) {
62399       {
62400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (...) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62405       };
62406     }
62407   }
62408   jresult = result;
62409   return jresult;
62410 }
62411
62412
62413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
62414   float jresult ;
62415   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62416   float result;
62417
62418   arg1 = (Dali::Toolkit::Button *)jarg1;
62419   {
62420     try {
62421       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
62422     } catch (std::out_of_range& e) {
62423       {
62424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62425       };
62426     } catch (std::exception& e) {
62427       {
62428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (...) {
62431       {
62432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62433       };
62434     }
62435   }
62436   jresult = result;
62437   return jresult;
62438 }
62439
62440
62441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
62442   float jresult ;
62443   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62444   float result;
62445
62446   arg1 = (Dali::Toolkit::Button *)jarg1;
62447   {
62448     try {
62449       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
62450     } catch (std::out_of_range& e) {
62451       {
62452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62453       };
62454     } catch (std::exception& e) {
62455       {
62456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62457       };
62458     } catch (...) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62461       };
62462     }
62463   }
62464   jresult = result;
62465   return jresult;
62466 }
62467
62468
62469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
62470   unsigned int jresult ;
62471   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62472   bool result;
62473
62474   arg1 = (Dali::Toolkit::Button *)jarg1;
62475   {
62476     try {
62477       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
62478     } catch (std::out_of_range& e) {
62479       {
62480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62481       };
62482     } catch (std::exception& e) {
62483       {
62484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62485       };
62486     } catch (...) {
62487       {
62488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62489       };
62490     }
62491   }
62492   jresult = result;
62493   return jresult;
62494 }
62495
62496
62497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
62498   unsigned int jresult ;
62499   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62500   bool result;
62501
62502   arg1 = (Dali::Toolkit::Button *)jarg1;
62503   {
62504     try {
62505       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
62506     } catch (std::out_of_range& e) {
62507       {
62508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (std::exception& e) {
62511       {
62512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62513       };
62514     } catch (...) {
62515       {
62516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62517       };
62518     }
62519   }
62520   jresult = result;
62521   return jresult;
62522 }
62523
62524
62525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
62526   float jresult ;
62527   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62528   float result;
62529
62530   arg1 = (Dali::Toolkit::Button *)jarg1;
62531   {
62532     try {
62533       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
62534     } catch (std::out_of_range& e) {
62535       {
62536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62537       };
62538     } catch (std::exception& e) {
62539       {
62540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62541       };
62542     } catch (...) {
62543       {
62544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62545       };
62546     }
62547   }
62548   jresult = result;
62549   return jresult;
62550 }
62551
62552
62553 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
62554   char * jresult ;
62555   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62556   std::string result;
62557
62558   arg1 = (Dali::Toolkit::Button *)jarg1;
62559   {
62560     try {
62561       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
62562     } catch (std::out_of_range& e) {
62563       {
62564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62565       };
62566     } catch (std::exception& e) {
62567       {
62568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (...) {
62571       {
62572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62573       };
62574     }
62575   }
62576   jresult = SWIG_csharp_string_callback((&result)->c_str());
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
62582   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62583   Dali::Actor arg2 ;
62584   Dali::Actor *argp2 ;
62585
62586   arg1 = (Dali::Toolkit::Button *)jarg1;
62587   argp2 = (Dali::Actor *)jarg2;
62588   if (!argp2) {
62589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62590     return ;
62591   }
62592   arg2 = *argp2;
62593   {
62594     try {
62595       (arg1)->SetLabel(arg2);
62596     } catch (std::out_of_range& e) {
62597       {
62598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62599       };
62600     } catch (std::exception& e) {
62601       {
62602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62603       };
62604     } catch (...) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62607       };
62608     }
62609   }
62610 }
62611
62612
62613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
62614   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62615   Dali::Image arg2 ;
62616   Dali::Image *argp2 ;
62617
62618   arg1 = (Dali::Toolkit::Button *)jarg1;
62619   argp2 = (Dali::Image *)jarg2;
62620   if (!argp2) {
62621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62622     return ;
62623   }
62624   arg2 = *argp2;
62625   {
62626     try {
62627       (arg1)->SetButtonImage(arg2);
62628     } catch (std::out_of_range& e) {
62629       {
62630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62631       };
62632     } catch (std::exception& e) {
62633       {
62634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62635       };
62636     } catch (...) {
62637       {
62638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62639       };
62640     }
62641   }
62642 }
62643
62644
62645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
62646   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62647   Dali::Image arg2 ;
62648   Dali::Image *argp2 ;
62649
62650   arg1 = (Dali::Toolkit::Button *)jarg1;
62651   argp2 = (Dali::Image *)jarg2;
62652   if (!argp2) {
62653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62654     return ;
62655   }
62656   arg2 = *argp2;
62657   {
62658     try {
62659       (arg1)->SetSelectedImage(arg2);
62660     } catch (std::out_of_range& e) {
62661       {
62662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62663       };
62664     } catch (std::exception& e) {
62665       {
62666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62667       };
62668     } catch (...) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62671       };
62672     }
62673   }
62674 }
62675
62676
62677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
62678   void * jresult ;
62679   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62680   Dali::Actor result;
62681
62682   arg1 = (Dali::Toolkit::Button *)jarg1;
62683   {
62684     try {
62685       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
62686     } catch (std::out_of_range& e) {
62687       {
62688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (std::exception& e) {
62691       {
62692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62697       };
62698     }
62699   }
62700   jresult = new Dali::Actor((const Dali::Actor &)result);
62701   return jresult;
62702 }
62703
62704
62705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
62706   void * jresult ;
62707   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62708   Dali::Actor result;
62709
62710   arg1 = (Dali::Toolkit::Button *)jarg1;
62711   {
62712     try {
62713       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
62714     } catch (std::out_of_range& e) {
62715       {
62716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62717       };
62718     } catch (std::exception& e) {
62719       {
62720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (...) {
62723       {
62724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62725       };
62726     }
62727   }
62728   jresult = new Dali::Actor((const Dali::Actor &)result);
62729   return jresult;
62730 }
62731
62732
62733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
62734   void * jresult ;
62735   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62736   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62737
62738   arg1 = (Dali::Toolkit::Button *)jarg1;
62739   {
62740     try {
62741       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
62742     } catch (std::out_of_range& e) {
62743       {
62744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62745       };
62746     } catch (std::exception& e) {
62747       {
62748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62749       };
62750     } catch (...) {
62751       {
62752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62753       };
62754     }
62755   }
62756   jresult = (void *)result;
62757   return jresult;
62758 }
62759
62760
62761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
62762   void * jresult ;
62763   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62764   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62765
62766   arg1 = (Dali::Toolkit::Button *)jarg1;
62767   {
62768     try {
62769       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
62770     } catch (std::out_of_range& e) {
62771       {
62772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62773       };
62774     } catch (std::exception& e) {
62775       {
62776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62777       };
62778     } catch (...) {
62779       {
62780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62781       };
62782     }
62783   }
62784   jresult = (void *)result;
62785   return jresult;
62786 }
62787
62788
62789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
62790   void * jresult ;
62791   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62792   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62793
62794   arg1 = (Dali::Toolkit::Button *)jarg1;
62795   {
62796     try {
62797       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
62798     } catch (std::out_of_range& e) {
62799       {
62800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62801       };
62802     } catch (std::exception& e) {
62803       {
62804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62805       };
62806     } catch (...) {
62807       {
62808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62809       };
62810     }
62811   }
62812   jresult = (void *)result;
62813   return jresult;
62814 }
62815
62816
62817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
62818   void * jresult ;
62819   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
62820   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
62821
62822   arg1 = (Dali::Toolkit::Button *)jarg1;
62823   {
62824     try {
62825       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
62826     } catch (std::out_of_range& e) {
62827       {
62828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (std::exception& e) {
62831       {
62832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (...) {
62835       {
62836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62837       };
62838     }
62839   }
62840   jresult = (void *)result;
62841   return jresult;
62842 }
62843
62844
62845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
62846   void * jresult ;
62847   Dali::Toolkit::CheckBoxButton *result = 0 ;
62848
62849   {
62850     try {
62851       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
62852     } catch (std::out_of_range& e) {
62853       {
62854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62855       };
62856     } catch (std::exception& e) {
62857       {
62858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62859       };
62860     } catch (...) {
62861       {
62862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62863       };
62864     }
62865   }
62866   jresult = (void *)result;
62867   return jresult;
62868 }
62869
62870
62871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
62872   void * jresult ;
62873   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
62874   Dali::Toolkit::CheckBoxButton *result = 0 ;
62875
62876   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62877   if (!arg1) {
62878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62879     return 0;
62880   }
62881   {
62882     try {
62883       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
62884     } catch (std::out_of_range& e) {
62885       {
62886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62887       };
62888     } catch (std::exception& e) {
62889       {
62890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62891       };
62892     } catch (...) {
62893       {
62894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62895       };
62896     }
62897   }
62898   jresult = (void *)result;
62899   return jresult;
62900 }
62901
62902
62903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
62904   void * jresult ;
62905   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62906   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
62907   Dali::Toolkit::CheckBoxButton *result = 0 ;
62908
62909   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62910   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
62911   if (!arg2) {
62912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
62913     return 0;
62914   }
62915   {
62916     try {
62917       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
62918     } catch (std::out_of_range& e) {
62919       {
62920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62921       };
62922     } catch (std::exception& e) {
62923       {
62924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62925       };
62926     } catch (...) {
62927       {
62928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62929       };
62930     }
62931   }
62932   jresult = (void *)result;
62933   return jresult;
62934 }
62935
62936
62937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
62938   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
62939
62940   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
62941   {
62942     try {
62943       delete arg1;
62944     } catch (std::out_of_range& e) {
62945       {
62946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62947       };
62948     } catch (std::exception& e) {
62949       {
62950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62951       };
62952     } catch (...) {
62953       {
62954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62955       };
62956     }
62957   }
62958 }
62959
62960
62961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
62962   void * jresult ;
62963   Dali::Toolkit::CheckBoxButton result;
62964
62965   {
62966     try {
62967       result = Dali::Toolkit::CheckBoxButton::New();
62968     } catch (std::out_of_range& e) {
62969       {
62970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62971       };
62972     } catch (std::exception& e) {
62973       {
62974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62975       };
62976     } catch (...) {
62977       {
62978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62979       };
62980     }
62981   }
62982   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
62983   return jresult;
62984 }
62985
62986
62987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
62988   void * jresult ;
62989   Dali::BaseHandle arg1 ;
62990   Dali::BaseHandle *argp1 ;
62991   Dali::Toolkit::CheckBoxButton result;
62992
62993   argp1 = (Dali::BaseHandle *)jarg1;
62994   if (!argp1) {
62995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62996     return 0;
62997   }
62998   arg1 = *argp1;
62999   {
63000     try {
63001       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
63002     } catch (std::out_of_range& e) {
63003       {
63004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63005       };
63006     } catch (std::exception& e) {
63007       {
63008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (...) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63013       };
63014     }
63015   }
63016   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
63017   return jresult;
63018 }
63019
63020
63021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
63022   int jresult ;
63023   int result;
63024
63025   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
63026   jresult = (int)result;
63027   return jresult;
63028 }
63029
63030
63031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
63032   int jresult ;
63033   int result;
63034
63035   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
63036   jresult = (int)result;
63037   return jresult;
63038 }
63039
63040
63041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
63042   int jresult ;
63043   int result;
63044
63045   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
63046   jresult = (int)result;
63047   return jresult;
63048 }
63049
63050
63051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
63052   int jresult ;
63053   int result;
63054
63055   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
63056   jresult = (int)result;
63057   return jresult;
63058 }
63059
63060
63061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
63062   int jresult ;
63063   int result;
63064
63065   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
63066   jresult = (int)result;
63067   return jresult;
63068 }
63069
63070
63071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
63072   void * jresult ;
63073   Dali::Toolkit::PushButton::Property *result = 0 ;
63074
63075   {
63076     try {
63077       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
63078     } catch (std::out_of_range& e) {
63079       {
63080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (std::exception& e) {
63083       {
63084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63085       };
63086     } catch (...) {
63087       {
63088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63089       };
63090     }
63091   }
63092   jresult = (void *)result;
63093   return jresult;
63094 }
63095
63096
63097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
63098   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
63099
63100   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
63101   {
63102     try {
63103       delete arg1;
63104     } catch (std::out_of_range& e) {
63105       {
63106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63107       };
63108     } catch (std::exception& e) {
63109       {
63110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63111       };
63112     } catch (...) {
63113       {
63114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63115       };
63116     }
63117   }
63118 }
63119
63120
63121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
63122   void * jresult ;
63123   Dali::Toolkit::PushButton *result = 0 ;
63124
63125   {
63126     try {
63127       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
63128     } catch (std::out_of_range& e) {
63129       {
63130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (std::exception& e) {
63133       {
63134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142   jresult = (void *)result;
63143   return jresult;
63144 }
63145
63146
63147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
63148   void * jresult ;
63149   Dali::Toolkit::PushButton *arg1 = 0 ;
63150   Dali::Toolkit::PushButton *result = 0 ;
63151
63152   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63153   if (!arg1) {
63154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63155     return 0;
63156   }
63157   {
63158     try {
63159       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
63160     } catch (std::out_of_range& e) {
63161       {
63162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63163       };
63164     } catch (std::exception& e) {
63165       {
63166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63167       };
63168     } catch (...) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63171       };
63172     }
63173   }
63174   jresult = (void *)result;
63175   return jresult;
63176 }
63177
63178
63179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
63180   void * jresult ;
63181   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63182   Dali::Toolkit::PushButton *arg2 = 0 ;
63183   Dali::Toolkit::PushButton *result = 0 ;
63184
63185   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63186   arg2 = (Dali::Toolkit::PushButton *)jarg2;
63187   if (!arg2) {
63188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
63189     return 0;
63190   }
63191   {
63192     try {
63193       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
63194     } catch (std::out_of_range& e) {
63195       {
63196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (std::exception& e) {
63199       {
63200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208   jresult = (void *)result;
63209   return jresult;
63210 }
63211
63212
63213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
63214   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63215
63216   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63217   {
63218     try {
63219       delete arg1;
63220     } catch (std::out_of_range& e) {
63221       {
63222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63223       };
63224     } catch (std::exception& e) {
63225       {
63226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63231       };
63232     }
63233   }
63234 }
63235
63236
63237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
63238   void * jresult ;
63239   Dali::Toolkit::PushButton result;
63240
63241   {
63242     try {
63243       result = Dali::Toolkit::PushButton::New();
63244     } catch (std::out_of_range& e) {
63245       {
63246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63247       };
63248     } catch (std::exception& e) {
63249       {
63250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (...) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63255       };
63256     }
63257   }
63258   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63259   return jresult;
63260 }
63261
63262
63263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
63264   void * jresult ;
63265   Dali::BaseHandle arg1 ;
63266   Dali::BaseHandle *argp1 ;
63267   Dali::Toolkit::PushButton result;
63268
63269   argp1 = (Dali::BaseHandle *)jarg1;
63270   if (!argp1) {
63271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63272     return 0;
63273   }
63274   arg1 = *argp1;
63275   {
63276     try {
63277       result = Dali::Toolkit::PushButton::DownCast(arg1);
63278     } catch (std::out_of_range& e) {
63279       {
63280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63281       };
63282     } catch (std::exception& e) {
63283       {
63284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63285       };
63286     } catch (...) {
63287       {
63288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63289       };
63290     }
63291   }
63292   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
63293   return jresult;
63294 }
63295
63296
63297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
63298   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63299   Dali::Image arg2 ;
63300   Dali::Image *argp2 ;
63301
63302   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63303   argp2 = (Dali::Image *)jarg2;
63304   if (!argp2) {
63305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63306     return ;
63307   }
63308   arg2 = *argp2;
63309   {
63310     try {
63311       (arg1)->SetButtonImage(arg2);
63312     } catch (std::out_of_range& e) {
63313       {
63314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63315       };
63316     } catch (std::exception& e) {
63317       {
63318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63319       };
63320     } catch (...) {
63321       {
63322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63323       };
63324     }
63325   }
63326 }
63327
63328
63329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
63330   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63331   Dali::Actor arg2 ;
63332   Dali::Actor *argp2 ;
63333
63334   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63335   argp2 = (Dali::Actor *)jarg2;
63336   if (!argp2) {
63337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63338     return ;
63339   }
63340   arg2 = *argp2;
63341   {
63342     try {
63343       (arg1)->SetButtonImage(arg2);
63344     } catch (std::out_of_range& e) {
63345       {
63346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63347       };
63348     } catch (std::exception& e) {
63349       {
63350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63351       };
63352     } catch (...) {
63353       {
63354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63355       };
63356     }
63357   }
63358 }
63359
63360
63361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
63362   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63363   Dali::Actor arg2 ;
63364   Dali::Actor *argp2 ;
63365
63366   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63367   argp2 = (Dali::Actor *)jarg2;
63368   if (!argp2) {
63369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63370     return ;
63371   }
63372   arg2 = *argp2;
63373   {
63374     try {
63375       (arg1)->SetBackgroundImage(arg2);
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63387       };
63388     }
63389   }
63390 }
63391
63392
63393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
63394   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63395   Dali::Image arg2 ;
63396   Dali::Image *argp2 ;
63397
63398   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63399   argp2 = (Dali::Image *)jarg2;
63400   if (!argp2) {
63401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63402     return ;
63403   }
63404   arg2 = *argp2;
63405   {
63406     try {
63407       (arg1)->SetSelectedImage(arg2);
63408     } catch (std::out_of_range& e) {
63409       {
63410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63411       };
63412     } catch (std::exception& e) {
63413       {
63414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63419       };
63420     }
63421   }
63422 }
63423
63424
63425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
63426   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63427   Dali::Actor arg2 ;
63428   Dali::Actor *argp2 ;
63429
63430   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63431   argp2 = (Dali::Actor *)jarg2;
63432   if (!argp2) {
63433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63434     return ;
63435   }
63436   arg2 = *argp2;
63437   {
63438     try {
63439       (arg1)->SetSelectedImage(arg2);
63440     } catch (std::out_of_range& e) {
63441       {
63442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63443       };
63444     } catch (std::exception& e) {
63445       {
63446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63447       };
63448     } catch (...) {
63449       {
63450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63451       };
63452     }
63453   }
63454 }
63455
63456
63457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
63458   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63459   Dali::Actor arg2 ;
63460   Dali::Actor *argp2 ;
63461
63462   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63463   argp2 = (Dali::Actor *)jarg2;
63464   if (!argp2) {
63465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63466     return ;
63467   }
63468   arg2 = *argp2;
63469   {
63470     try {
63471       (arg1)->SetSelectedBackgroundImage(arg2);
63472     } catch (std::out_of_range& e) {
63473       {
63474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63475       };
63476     } catch (std::exception& e) {
63477       {
63478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63479       };
63480     } catch (...) {
63481       {
63482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63483       };
63484     }
63485   }
63486 }
63487
63488
63489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
63490   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63491   Dali::Actor arg2 ;
63492   Dali::Actor *argp2 ;
63493
63494   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63495   argp2 = (Dali::Actor *)jarg2;
63496   if (!argp2) {
63497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63498     return ;
63499   }
63500   arg2 = *argp2;
63501   {
63502     try {
63503       (arg1)->SetDisabledBackgroundImage(arg2);
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63511       };
63512     } catch (...) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63515       };
63516     }
63517   }
63518 }
63519
63520
63521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
63522   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63523   Dali::Actor arg2 ;
63524   Dali::Actor *argp2 ;
63525
63526   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63527   argp2 = (Dali::Actor *)jarg2;
63528   if (!argp2) {
63529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63530     return ;
63531   }
63532   arg2 = *argp2;
63533   {
63534     try {
63535       (arg1)->SetDisabledImage(arg2);
63536     } catch (std::out_of_range& e) {
63537       {
63538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63539       };
63540     } catch (std::exception& e) {
63541       {
63542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63543       };
63544     } catch (...) {
63545       {
63546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63547       };
63548     }
63549   }
63550 }
63551
63552
63553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
63554   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
63555   Dali::Actor arg2 ;
63556   Dali::Actor *argp2 ;
63557
63558   arg1 = (Dali::Toolkit::PushButton *)jarg1;
63559   argp2 = (Dali::Actor *)jarg2;
63560   if (!argp2) {
63561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
63562     return ;
63563   }
63564   arg2 = *argp2;
63565   {
63566     try {
63567       (arg1)->SetDisabledSelectedImage(arg2);
63568     } catch (std::out_of_range& e) {
63569       {
63570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63571       };
63572     } catch (std::exception& e) {
63573       {
63574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63575       };
63576     } catch (...) {
63577       {
63578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63579       };
63580     }
63581   }
63582 }
63583
63584
63585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
63586   void * jresult ;
63587   Dali::Toolkit::RadioButton *result = 0 ;
63588
63589   {
63590     try {
63591       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
63592     } catch (std::out_of_range& e) {
63593       {
63594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63595       };
63596     } catch (std::exception& e) {
63597       {
63598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63599       };
63600     } catch (...) {
63601       {
63602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63603       };
63604     }
63605   }
63606   jresult = (void *)result;
63607   return jresult;
63608 }
63609
63610
63611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
63612   void * jresult ;
63613   Dali::Toolkit::RadioButton *arg1 = 0 ;
63614   Dali::Toolkit::RadioButton *result = 0 ;
63615
63616   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63617   if (!arg1) {
63618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63619     return 0;
63620   }
63621   {
63622     try {
63623       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
63624     } catch (std::out_of_range& e) {
63625       {
63626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63627       };
63628     } catch (std::exception& e) {
63629       {
63630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63631       };
63632     } catch (...) {
63633       {
63634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63635       };
63636     }
63637   }
63638   jresult = (void *)result;
63639   return jresult;
63640 }
63641
63642
63643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
63644   void * jresult ;
63645   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63646   Dali::Toolkit::RadioButton *arg2 = 0 ;
63647   Dali::Toolkit::RadioButton *result = 0 ;
63648
63649   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63650   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
63651   if (!arg2) {
63652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
63653     return 0;
63654   }
63655   {
63656     try {
63657       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
63658     } catch (std::out_of_range& e) {
63659       {
63660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63661       };
63662     } catch (std::exception& e) {
63663       {
63664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63665       };
63666     } catch (...) {
63667       {
63668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63669       };
63670     }
63671   }
63672   jresult = (void *)result;
63673   return jresult;
63674 }
63675
63676
63677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
63678   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
63679
63680   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
63681   {
63682     try {
63683       delete arg1;
63684     } catch (std::out_of_range& e) {
63685       {
63686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63687       };
63688     } catch (std::exception& e) {
63689       {
63690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63691       };
63692     } catch (...) {
63693       {
63694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63695       };
63696     }
63697   }
63698 }
63699
63700
63701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
63702   void * jresult ;
63703   Dali::Toolkit::RadioButton result;
63704
63705   {
63706     try {
63707       result = Dali::Toolkit::RadioButton::New();
63708     } catch (std::out_of_range& e) {
63709       {
63710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63711       };
63712     } catch (std::exception& e) {
63713       {
63714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63715       };
63716     } catch (...) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63719       };
63720     }
63721   }
63722   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63723   return jresult;
63724 }
63725
63726
63727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
63728   void * jresult ;
63729   std::string *arg1 = 0 ;
63730   Dali::Toolkit::RadioButton result;
63731
63732   if (!jarg1) {
63733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63734     return 0;
63735   }
63736   std::string arg1_str(jarg1);
63737   arg1 = &arg1_str;
63738   {
63739     try {
63740       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
63741     } catch (std::out_of_range& e) {
63742       {
63743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63744       };
63745     } catch (std::exception& e) {
63746       {
63747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63748       };
63749     } catch (...) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63752       };
63753     }
63754   }
63755   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63756
63757   //argout typemap for const std::string&
63758
63759   return jresult;
63760 }
63761
63762
63763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
63764   void * jresult ;
63765   Dali::BaseHandle arg1 ;
63766   Dali::BaseHandle *argp1 ;
63767   Dali::Toolkit::RadioButton result;
63768
63769   argp1 = (Dali::BaseHandle *)jarg1;
63770   if (!argp1) {
63771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63772     return 0;
63773   }
63774   arg1 = *argp1;
63775   {
63776     try {
63777       result = Dali::Toolkit::RadioButton::DownCast(arg1);
63778     } catch (std::out_of_range& e) {
63779       {
63780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63781       };
63782     } catch (std::exception& e) {
63783       {
63784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63785       };
63786     } catch (...) {
63787       {
63788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63789       };
63790     }
63791   }
63792   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
63793   return jresult;
63794 }
63795
63796
63797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
63798   int jresult ;
63799   int result;
63800
63801   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
63802   jresult = (int)result;
63803   return jresult;
63804 }
63805
63806
63807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
63808   int jresult ;
63809   int result;
63810
63811   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
63812   jresult = (int)result;
63813   return jresult;
63814 }
63815
63816
63817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
63818   int jresult ;
63819   int result;
63820
63821   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
63822   jresult = (int)result;
63823   return jresult;
63824 }
63825
63826
63827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
63828   int jresult ;
63829   int result;
63830
63831   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
63832   jresult = (int)result;
63833   return jresult;
63834 }
63835
63836
63837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
63838   int jresult ;
63839   int result;
63840
63841   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
63842   jresult = (int)result;
63843   return jresult;
63844 }
63845
63846
63847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
63848   int jresult ;
63849   int result;
63850
63851   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
63852   jresult = (int)result;
63853   return jresult;
63854 }
63855
63856
63857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
63858   void * jresult ;
63859   Dali::Toolkit::FlexContainer::Property *result = 0 ;
63860
63861   {
63862     try {
63863       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
63864     } catch (std::out_of_range& e) {
63865       {
63866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63867       };
63868     } catch (std::exception& e) {
63869       {
63870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63871       };
63872     } catch (...) {
63873       {
63874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63875       };
63876     }
63877   }
63878   jresult = (void *)result;
63879   return jresult;
63880 }
63881
63882
63883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
63884   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
63885
63886   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
63887   {
63888     try {
63889       delete arg1;
63890     } catch (std::out_of_range& e) {
63891       {
63892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63893       };
63894     } catch (std::exception& e) {
63895       {
63896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63897       };
63898     } catch (...) {
63899       {
63900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63901       };
63902     }
63903   }
63904 }
63905
63906
63907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
63908   int jresult ;
63909   int result;
63910
63911   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
63912   jresult = (int)result;
63913   return jresult;
63914 }
63915
63916
63917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
63918   int jresult ;
63919   int result;
63920
63921   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
63922   jresult = (int)result;
63923   return jresult;
63924 }
63925
63926
63927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
63928   int jresult ;
63929   int result;
63930
63931   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
63932   jresult = (int)result;
63933   return jresult;
63934 }
63935
63936
63937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
63938   void * jresult ;
63939   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
63940
63941   {
63942     try {
63943       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
63944     } catch (std::out_of_range& e) {
63945       {
63946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63947       };
63948     } catch (std::exception& e) {
63949       {
63950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63951       };
63952     } catch (...) {
63953       {
63954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63955       };
63956     }
63957   }
63958   jresult = (void *)result;
63959   return jresult;
63960 }
63961
63962
63963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
63964   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
63965
63966   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
63967   {
63968     try {
63969       delete arg1;
63970     } catch (std::out_of_range& e) {
63971       {
63972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63973       };
63974     } catch (std::exception& e) {
63975       {
63976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63977       };
63978     } catch (...) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63981       };
63982     }
63983   }
63984 }
63985
63986
63987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
63988   void * jresult ;
63989   Dali::Toolkit::FlexContainer *result = 0 ;
63990
63991   {
63992     try {
63993       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
63994     } catch (std::out_of_range& e) {
63995       {
63996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63997       };
63998     } catch (std::exception& e) {
63999       {
64000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64001       };
64002     } catch (...) {
64003       {
64004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64005       };
64006     }
64007   }
64008   jresult = (void *)result;
64009   return jresult;
64010 }
64011
64012
64013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
64014   void * jresult ;
64015   Dali::Toolkit::FlexContainer *arg1 = 0 ;
64016   Dali::Toolkit::FlexContainer *result = 0 ;
64017
64018   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64019   if (!arg1) {
64020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
64021     return 0;
64022   }
64023   {
64024     try {
64025       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (...) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64037       };
64038     }
64039   }
64040   jresult = (void *)result;
64041   return jresult;
64042 }
64043
64044
64045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
64046   void * jresult ;
64047   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
64048   Dali::Toolkit::FlexContainer *arg2 = 0 ;
64049   Dali::Toolkit::FlexContainer *result = 0 ;
64050
64051   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64052   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
64053   if (!arg2) {
64054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
64055     return 0;
64056   }
64057   {
64058     try {
64059       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
64060     } catch (std::out_of_range& e) {
64061       {
64062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64063       };
64064     } catch (std::exception& e) {
64065       {
64066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64067       };
64068     } catch (...) {
64069       {
64070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64071       };
64072     }
64073   }
64074   jresult = (void *)result;
64075   return jresult;
64076 }
64077
64078
64079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
64080   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
64081
64082   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
64083   {
64084     try {
64085       delete arg1;
64086     } catch (std::out_of_range& e) {
64087       {
64088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64089       };
64090     } catch (std::exception& e) {
64091       {
64092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64093       };
64094     } catch (...) {
64095       {
64096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64097       };
64098     }
64099   }
64100 }
64101
64102
64103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
64104   void * jresult ;
64105   Dali::Toolkit::FlexContainer result;
64106
64107   {
64108     try {
64109       result = Dali::Toolkit::FlexContainer::New();
64110     } catch (std::out_of_range& e) {
64111       {
64112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64113       };
64114     } catch (std::exception& e) {
64115       {
64116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64117       };
64118     } catch (...) {
64119       {
64120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64121       };
64122     }
64123   }
64124   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64125   return jresult;
64126 }
64127
64128
64129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
64130   void * jresult ;
64131   Dali::BaseHandle arg1 ;
64132   Dali::BaseHandle *argp1 ;
64133   Dali::Toolkit::FlexContainer result;
64134
64135   argp1 = (Dali::BaseHandle *)jarg1;
64136   if (!argp1) {
64137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64138     return 0;
64139   }
64140   arg1 = *argp1;
64141   {
64142     try {
64143       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
64144     } catch (std::out_of_range& e) {
64145       {
64146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64147       };
64148     } catch (std::exception& e) {
64149       {
64150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64151       };
64152     } catch (...) {
64153       {
64154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64155       };
64156     }
64157   }
64158   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
64159   return jresult;
64160 }
64161
64162
64163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
64164   int jresult ;
64165   int result;
64166
64167   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
64168   jresult = (int)result;
64169   return jresult;
64170 }
64171
64172
64173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
64174   int jresult ;
64175   int result;
64176
64177   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
64178   jresult = (int)result;
64179   return jresult;
64180 }
64181
64182
64183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
64184   int jresult ;
64185   int result;
64186
64187   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
64188   jresult = (int)result;
64189   return jresult;
64190 }
64191
64192
64193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
64194   int jresult ;
64195   int result;
64196
64197   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
64198   jresult = (int)result;
64199   return jresult;
64200 }
64201
64202
64203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
64204   void * jresult ;
64205   Dali::Toolkit::ImageView::Property *result = 0 ;
64206
64207   {
64208     try {
64209       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
64210     } catch (std::out_of_range& e) {
64211       {
64212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (std::exception& e) {
64215       {
64216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64217       };
64218     } catch (...) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64221       };
64222     }
64223   }
64224   jresult = (void *)result;
64225   return jresult;
64226 }
64227
64228
64229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
64230   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
64231
64232   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
64233   {
64234     try {
64235       delete arg1;
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64243       };
64244     } catch (...) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64247       };
64248     }
64249   }
64250 }
64251
64252
64253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
64254   void * jresult ;
64255   Dali::Toolkit::ImageView *result = 0 ;
64256
64257   {
64258     try {
64259       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
64260     } catch (std::out_of_range& e) {
64261       {
64262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64263       };
64264     } catch (std::exception& e) {
64265       {
64266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64267       };
64268     } catch (...) {
64269       {
64270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64271       };
64272     }
64273   }
64274   jresult = (void *)result;
64275   return jresult;
64276 }
64277
64278
64279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
64280   void * jresult ;
64281   Dali::Toolkit::ImageView result;
64282
64283   {
64284     try {
64285       result = Dali::Toolkit::ImageView::New();
64286     } catch (std::out_of_range& e) {
64287       {
64288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64289       };
64290     } catch (std::exception& e) {
64291       {
64292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64293       };
64294     } catch (...) {
64295       {
64296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64297       };
64298     }
64299   }
64300   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64301   return jresult;
64302 }
64303
64304
64305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
64306   void * jresult ;
64307   Dali::Image arg1 ;
64308   Dali::Image *argp1 ;
64309   Dali::Toolkit::ImageView result;
64310
64311   argp1 = (Dali::Image *)jarg1;
64312   if (!argp1) {
64313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64314     return 0;
64315   }
64316   arg1 = *argp1;
64317   {
64318     try {
64319       result = Dali::Toolkit::ImageView::New(arg1);
64320     } catch (std::out_of_range& e) {
64321       {
64322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64323       };
64324     } catch (std::exception& e) {
64325       {
64326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64327       };
64328     } catch (...) {
64329       {
64330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64331       };
64332     }
64333   }
64334   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
64340   void * jresult ;
64341   std::string *arg1 = 0 ;
64342   Dali::Toolkit::ImageView result;
64343
64344   if (!jarg1) {
64345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64346     return 0;
64347   }
64348   std::string arg1_str(jarg1);
64349   arg1 = &arg1_str;
64350   {
64351     try {
64352       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
64353     } catch (std::out_of_range& e) {
64354       {
64355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64356       };
64357     } catch (std::exception& e) {
64358       {
64359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64360       };
64361     } catch (...) {
64362       {
64363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64364       };
64365     }
64366   }
64367   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64368
64369   //argout typemap for const std::string&
64370
64371   return jresult;
64372 }
64373
64374
64375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
64376   void * jresult ;
64377   std::string *arg1 = 0 ;
64378   Dali::ImageDimensions arg2 ;
64379   Dali::ImageDimensions *argp2 ;
64380   Dali::Toolkit::ImageView result;
64381
64382   if (!jarg1) {
64383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64384     return 0;
64385   }
64386   std::string arg1_str(jarg1);
64387   arg1 = &arg1_str;
64388   argp2 = (Dali::ImageDimensions *)jarg2;
64389   if (!argp2) {
64390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64391     return 0;
64392   }
64393   arg2 = *argp2;
64394   {
64395     try {
64396       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
64397     } catch (std::out_of_range& e) {
64398       {
64399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64400       };
64401     } catch (std::exception& e) {
64402       {
64403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64404       };
64405     } catch (...) {
64406       {
64407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64408       };
64409     }
64410   }
64411   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64412
64413   //argout typemap for const std::string&
64414
64415   return jresult;
64416 }
64417
64418
64419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
64420   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64421
64422   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64423   {
64424     try {
64425       delete arg1;
64426     } catch (std::out_of_range& e) {
64427       {
64428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64429       };
64430     } catch (std::exception& e) {
64431       {
64432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64433       };
64434     } catch (...) {
64435       {
64436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64437       };
64438     }
64439   }
64440 }
64441
64442
64443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
64444   void * jresult ;
64445   Dali::Toolkit::ImageView *arg1 = 0 ;
64446   Dali::Toolkit::ImageView *result = 0 ;
64447
64448   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64449   if (!arg1) {
64450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64451     return 0;
64452   }
64453   {
64454     try {
64455       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
64456     } catch (std::out_of_range& e) {
64457       {
64458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64459       };
64460     } catch (std::exception& e) {
64461       {
64462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64463       };
64464     } catch (...) {
64465       {
64466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64467       };
64468     }
64469   }
64470   jresult = (void *)result;
64471   return jresult;
64472 }
64473
64474
64475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
64476   void * jresult ;
64477   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64478   Dali::Toolkit::ImageView *arg2 = 0 ;
64479   Dali::Toolkit::ImageView *result = 0 ;
64480
64481   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64482   arg2 = (Dali::Toolkit::ImageView *)jarg2;
64483   if (!arg2) {
64484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
64485     return 0;
64486   }
64487   {
64488     try {
64489       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
64490     } catch (std::out_of_range& e) {
64491       {
64492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64493       };
64494     } catch (std::exception& e) {
64495       {
64496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64497       };
64498     } catch (...) {
64499       {
64500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64501       };
64502     }
64503   }
64504   jresult = (void *)result;
64505   return jresult;
64506 }
64507
64508
64509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
64510   void * jresult ;
64511   Dali::BaseHandle arg1 ;
64512   Dali::BaseHandle *argp1 ;
64513   Dali::Toolkit::ImageView result;
64514
64515   argp1 = (Dali::BaseHandle *)jarg1;
64516   if (!argp1) {
64517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64518     return 0;
64519   }
64520   arg1 = *argp1;
64521   {
64522     try {
64523       result = Dali::Toolkit::ImageView::DownCast(arg1);
64524     } catch (std::out_of_range& e) {
64525       {
64526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64527       };
64528     } catch (std::exception& e) {
64529       {
64530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64531       };
64532     } catch (...) {
64533       {
64534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64535       };
64536     }
64537   }
64538   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
64539   return jresult;
64540 }
64541
64542
64543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
64544   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64545   Dali::Image arg2 ;
64546   Dali::Image *argp2 ;
64547
64548   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64549   argp2 = (Dali::Image *)jarg2;
64550   if (!argp2) {
64551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64552     return ;
64553   }
64554   arg2 = *argp2;
64555   {
64556     try {
64557       (arg1)->SetImage(arg2);
64558     } catch (std::out_of_range& e) {
64559       {
64560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64561       };
64562     } catch (std::exception& e) {
64563       {
64564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64569       };
64570     }
64571   }
64572 }
64573
64574
64575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
64576   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64577   std::string *arg2 = 0 ;
64578
64579   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64580   if (!jarg2) {
64581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64582     return ;
64583   }
64584   std::string arg2_str(jarg2);
64585   arg2 = &arg2_str;
64586   {
64587     try {
64588       (arg1)->SetImage((std::string const &)*arg2);
64589     } catch (std::out_of_range& e) {
64590       {
64591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64592       };
64593     } catch (std::exception& e) {
64594       {
64595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64596       };
64597     } catch (...) {
64598       {
64599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64600       };
64601     }
64602   }
64603
64604   //argout typemap for const std::string&
64605
64606 }
64607
64608
64609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
64610   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64611   std::string *arg2 = 0 ;
64612   Dali::ImageDimensions arg3 ;
64613   Dali::ImageDimensions *argp3 ;
64614
64615   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64616   if (!jarg2) {
64617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64618     return ;
64619   }
64620   std::string arg2_str(jarg2);
64621   arg2 = &arg2_str;
64622   argp3 = (Dali::ImageDimensions *)jarg3;
64623   if (!argp3) {
64624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
64625     return ;
64626   }
64627   arg3 = *argp3;
64628   {
64629     try {
64630       (arg1)->SetImage((std::string const &)*arg2,arg3);
64631     } catch (std::out_of_range& e) {
64632       {
64633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64634       };
64635     } catch (std::exception& e) {
64636       {
64637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64638       };
64639     } catch (...) {
64640       {
64641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64642       };
64643     }
64644   }
64645
64646   //argout typemap for const std::string&
64647
64648 }
64649
64650
64651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
64652   void * jresult ;
64653   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
64654   Dali::Image result;
64655
64656   arg1 = (Dali::Toolkit::ImageView *)jarg1;
64657   {
64658     try {
64659       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
64660     } catch (std::out_of_range& e) {
64661       {
64662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64663       };
64664     } catch (std::exception& e) {
64665       {
64666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64667       };
64668     } catch (...) {
64669       {
64670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64671       };
64672     }
64673   }
64674   jresult = new Dali::Image((const Dali::Image &)result);
64675   return jresult;
64676 }
64677
64678
64679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
64680   int jresult ;
64681   int result;
64682
64683   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
64684   jresult = (int)result;
64685   return jresult;
64686 }
64687
64688
64689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
64690   int jresult ;
64691   int result;
64692
64693   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
64694   jresult = (int)result;
64695   return jresult;
64696 }
64697
64698
64699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
64700   int jresult ;
64701   int result;
64702
64703   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
64704   jresult = (int)result;
64705   return jresult;
64706 }
64707
64708
64709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
64710   int jresult ;
64711   int result;
64712
64713   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
64714   jresult = (int)result;
64715   return jresult;
64716 }
64717
64718
64719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
64720   int jresult ;
64721   int result;
64722
64723   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
64724   jresult = (int)result;
64725   return jresult;
64726 }
64727
64728
64729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
64730   int jresult ;
64731   int result;
64732
64733   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
64734   jresult = (int)result;
64735   return jresult;
64736 }
64737
64738
64739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
64740   int jresult ;
64741   int result;
64742
64743   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
64744   jresult = (int)result;
64745   return jresult;
64746 }
64747
64748
64749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
64750   int jresult ;
64751   int result;
64752
64753   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
64754   jresult = (int)result;
64755   return jresult;
64756 }
64757
64758
64759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
64760   void * jresult ;
64761   Dali::Toolkit::Model3dView::Property *result = 0 ;
64762
64763   {
64764     try {
64765       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
64766     } catch (std::out_of_range& e) {
64767       {
64768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64769       };
64770     } catch (std::exception& e) {
64771       {
64772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64773       };
64774     } catch (...) {
64775       {
64776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64777       };
64778     }
64779   }
64780   jresult = (void *)result;
64781   return jresult;
64782 }
64783
64784
64785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
64786   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
64787
64788   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
64789   {
64790     try {
64791       delete arg1;
64792     } catch (std::out_of_range& e) {
64793       {
64794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64795       };
64796     } catch (std::exception& e) {
64797       {
64798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64799       };
64800     } catch (...) {
64801       {
64802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64803       };
64804     }
64805   }
64806 }
64807
64808
64809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
64810   void * jresult ;
64811   Dali::Toolkit::Model3dView result;
64812
64813   {
64814     try {
64815       result = Dali::Toolkit::Model3dView::New();
64816     } catch (std::out_of_range& e) {
64817       {
64818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64819       };
64820     } catch (std::exception& e) {
64821       {
64822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64823       };
64824     } catch (...) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64827       };
64828     }
64829   }
64830   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64831   return jresult;
64832 }
64833
64834
64835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
64836   void * jresult ;
64837   std::string *arg1 = 0 ;
64838   std::string *arg2 = 0 ;
64839   std::string *arg3 = 0 ;
64840   Dali::Toolkit::Model3dView result;
64841
64842   if (!jarg1) {
64843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64844     return 0;
64845   }
64846   std::string arg1_str(jarg1);
64847   arg1 = &arg1_str;
64848   if (!jarg2) {
64849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64850     return 0;
64851   }
64852   std::string arg2_str(jarg2);
64853   arg2 = &arg2_str;
64854   if (!jarg3) {
64855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
64856     return 0;
64857   }
64858   std::string arg3_str(jarg3);
64859   arg3 = &arg3_str;
64860   {
64861     try {
64862       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64870       };
64871     } catch (...) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64874       };
64875     }
64876   }
64877   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
64878
64879   //argout typemap for const std::string&
64880
64881
64882   //argout typemap for const std::string&
64883
64884
64885   //argout typemap for const std::string&
64886
64887   return jresult;
64888 }
64889
64890
64891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
64892   void * jresult ;
64893   Dali::Toolkit::Model3dView *result = 0 ;
64894
64895   {
64896     try {
64897       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
64898     } catch (std::out_of_range& e) {
64899       {
64900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64901       };
64902     } catch (std::exception& e) {
64903       {
64904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64905       };
64906     } catch (...) {
64907       {
64908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64909       };
64910     }
64911   }
64912   jresult = (void *)result;
64913   return jresult;
64914 }
64915
64916
64917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
64918   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64919
64920   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64921   {
64922     try {
64923       delete arg1;
64924     } catch (std::out_of_range& e) {
64925       {
64926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64927       };
64928     } catch (std::exception& e) {
64929       {
64930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64931       };
64932     } catch (...) {
64933       {
64934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64935       };
64936     }
64937   }
64938 }
64939
64940
64941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
64942   void * jresult ;
64943   Dali::Toolkit::Model3dView *arg1 = 0 ;
64944   Dali::Toolkit::Model3dView *result = 0 ;
64945
64946   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64947   if (!arg1) {
64948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64949     return 0;
64950   }
64951   {
64952     try {
64953       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
64954     } catch (std::out_of_range& e) {
64955       {
64956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64957       };
64958     } catch (std::exception& e) {
64959       {
64960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64961       };
64962     } catch (...) {
64963       {
64964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64965       };
64966     }
64967   }
64968   jresult = (void *)result;
64969   return jresult;
64970 }
64971
64972
64973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
64974   void * jresult ;
64975   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
64976   Dali::Toolkit::Model3dView *arg2 = 0 ;
64977   Dali::Toolkit::Model3dView *result = 0 ;
64978
64979   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
64980   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
64981   if (!arg2) {
64982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
64983     return 0;
64984   }
64985   {
64986     try {
64987       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
64988     } catch (std::out_of_range& e) {
64989       {
64990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64991       };
64992     } catch (std::exception& e) {
64993       {
64994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64995       };
64996     } catch (...) {
64997       {
64998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64999       };
65000     }
65001   }
65002   jresult = (void *)result;
65003   return jresult;
65004 }
65005
65006
65007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
65008   void * jresult ;
65009   Dali::BaseHandle arg1 ;
65010   Dali::BaseHandle *argp1 ;
65011   Dali::Toolkit::Model3dView result;
65012
65013   argp1 = (Dali::BaseHandle *)jarg1;
65014   if (!argp1) {
65015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65016     return 0;
65017   }
65018   arg1 = *argp1;
65019   {
65020     try {
65021       result = Dali::Toolkit::Model3dView::DownCast(arg1);
65022     } catch (std::out_of_range& e) {
65023       {
65024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65025       };
65026     } catch (std::exception& e) {
65027       {
65028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65029       };
65030     } catch (...) {
65031       {
65032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65033       };
65034     }
65035   }
65036   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
65037   return jresult;
65038 }
65039
65040
65041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
65042   int jresult ;
65043   int result;
65044
65045   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
65046   jresult = (int)result;
65047   return jresult;
65048 }
65049
65050
65051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
65052   int jresult ;
65053   int result;
65054
65055   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
65056   jresult = (int)result;
65057   return jresult;
65058 }
65059
65060
65061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
65062   int jresult ;
65063   int result;
65064
65065   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
65066   jresult = (int)result;
65067   return jresult;
65068 }
65069
65070
65071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
65072   int jresult ;
65073   int result;
65074
65075   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
65076   jresult = (int)result;
65077   return jresult;
65078 }
65079
65080
65081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
65082   int jresult ;
65083   int result;
65084
65085   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
65086   jresult = (int)result;
65087   return jresult;
65088 }
65089
65090
65091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
65092   int jresult ;
65093   int result;
65094
65095   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
65096   jresult = (int)result;
65097   return jresult;
65098 }
65099
65100
65101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
65102   int jresult ;
65103   int result;
65104
65105   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
65106   jresult = (int)result;
65107   return jresult;
65108 }
65109
65110
65111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
65112   int jresult ;
65113   int result;
65114
65115   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
65116   jresult = (int)result;
65117   return jresult;
65118 }
65119
65120
65121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
65122   int jresult ;
65123   int result;
65124
65125   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
65126   jresult = (int)result;
65127   return jresult;
65128 }
65129
65130
65131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
65132   void * jresult ;
65133   Dali::Toolkit::ScrollBar::Property *result = 0 ;
65134
65135   {
65136     try {
65137       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
65138     } catch (std::out_of_range& e) {
65139       {
65140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65141       };
65142     } catch (std::exception& e) {
65143       {
65144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (...) {
65147       {
65148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65149       };
65150     }
65151   }
65152   jresult = (void *)result;
65153   return jresult;
65154 }
65155
65156
65157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
65158   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
65159
65160   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
65161   {
65162     try {
65163       delete arg1;
65164     } catch (std::out_of_range& e) {
65165       {
65166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65167       };
65168     } catch (std::exception& e) {
65169       {
65170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65171       };
65172     } catch (...) {
65173       {
65174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65175       };
65176     }
65177   }
65178 }
65179
65180
65181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
65182   void * jresult ;
65183   Dali::Toolkit::ScrollBar *result = 0 ;
65184
65185   {
65186     try {
65187       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
65188     } catch (std::out_of_range& e) {
65189       {
65190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65191       };
65192     } catch (std::exception& e) {
65193       {
65194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (...) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65199       };
65200     }
65201   }
65202   jresult = (void *)result;
65203   return jresult;
65204 }
65205
65206
65207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
65208   void * jresult ;
65209   Dali::Toolkit::ScrollBar *arg1 = 0 ;
65210   Dali::Toolkit::ScrollBar *result = 0 ;
65211
65212   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65213   if (!arg1) {
65214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65215     return 0;
65216   }
65217   {
65218     try {
65219       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
65220     } catch (std::out_of_range& e) {
65221       {
65222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65223       };
65224     } catch (std::exception& e) {
65225       {
65226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65227       };
65228     } catch (...) {
65229       {
65230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65231       };
65232     }
65233   }
65234   jresult = (void *)result;
65235   return jresult;
65236 }
65237
65238
65239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
65240   void * jresult ;
65241   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65242   Dali::Toolkit::ScrollBar *arg2 = 0 ;
65243   Dali::Toolkit::ScrollBar *result = 0 ;
65244
65245   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65246   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
65247   if (!arg2) {
65248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
65249     return 0;
65250   }
65251   {
65252     try {
65253       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
65254     } catch (std::out_of_range& e) {
65255       {
65256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65257       };
65258     } catch (std::exception& e) {
65259       {
65260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65261       };
65262     } catch (...) {
65263       {
65264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65265       };
65266     }
65267   }
65268   jresult = (void *)result;
65269   return jresult;
65270 }
65271
65272
65273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
65274   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65275
65276   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65277   {
65278     try {
65279       delete arg1;
65280     } catch (std::out_of_range& e) {
65281       {
65282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65283       };
65284     } catch (std::exception& e) {
65285       {
65286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65287       };
65288     } catch (...) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65291       };
65292     }
65293   }
65294 }
65295
65296
65297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
65298   void * jresult ;
65299   Dali::Toolkit::ScrollBar::Direction arg1 ;
65300   Dali::Toolkit::ScrollBar result;
65301
65302   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
65303   {
65304     try {
65305       result = Dali::Toolkit::ScrollBar::New(arg1);
65306     } catch (std::out_of_range& e) {
65307       {
65308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65309       };
65310     } catch (std::exception& e) {
65311       {
65312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65313       };
65314     } catch (...) {
65315       {
65316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65317       };
65318     }
65319   }
65320   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65321   return jresult;
65322 }
65323
65324
65325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
65326   void * jresult ;
65327   Dali::Toolkit::ScrollBar result;
65328
65329   {
65330     try {
65331       result = Dali::Toolkit::ScrollBar::New();
65332     } catch (std::out_of_range& e) {
65333       {
65334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65335       };
65336     } catch (std::exception& e) {
65337       {
65338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65339       };
65340     } catch (...) {
65341       {
65342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65343       };
65344     }
65345   }
65346   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65347   return jresult;
65348 }
65349
65350
65351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
65352   void * jresult ;
65353   Dali::BaseHandle arg1 ;
65354   Dali::BaseHandle *argp1 ;
65355   Dali::Toolkit::ScrollBar result;
65356
65357   argp1 = (Dali::BaseHandle *)jarg1;
65358   if (!argp1) {
65359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65360     return 0;
65361   }
65362   arg1 = *argp1;
65363   {
65364     try {
65365       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
65366     } catch (std::out_of_range& e) {
65367       {
65368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65369       };
65370     } catch (std::exception& e) {
65371       {
65372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65373       };
65374     } catch (...) {
65375       {
65376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65377       };
65378     }
65379   }
65380   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
65381   return jresult;
65382 }
65383
65384
65385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
65386   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65387   Dali::Handle arg2 ;
65388   Dali::Property::Index arg3 ;
65389   Dali::Property::Index arg4 ;
65390   Dali::Property::Index arg5 ;
65391   Dali::Property::Index arg6 ;
65392   Dali::Handle *argp2 ;
65393
65394   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65395   argp2 = (Dali::Handle *)jarg2;
65396   if (!argp2) {
65397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
65398     return ;
65399   }
65400   arg2 = *argp2;
65401   arg3 = (Dali::Property::Index)jarg3;
65402   arg4 = (Dali::Property::Index)jarg4;
65403   arg5 = (Dali::Property::Index)jarg5;
65404   arg6 = (Dali::Property::Index)jarg6;
65405   {
65406     try {
65407       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
65408     } catch (std::out_of_range& e) {
65409       {
65410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65411       };
65412     } catch (std::exception& e) {
65413       {
65414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65415       };
65416     } catch (...) {
65417       {
65418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65419       };
65420     }
65421   }
65422 }
65423
65424
65425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
65426   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65427   Dali::Actor arg2 ;
65428   Dali::Actor *argp2 ;
65429
65430   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65431   argp2 = (Dali::Actor *)jarg2;
65432   if (!argp2) {
65433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65434     return ;
65435   }
65436   arg2 = *argp2;
65437   {
65438     try {
65439       (arg1)->SetScrollIndicator(arg2);
65440     } catch (std::out_of_range& e) {
65441       {
65442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65443       };
65444     } catch (std::exception& e) {
65445       {
65446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65447       };
65448     } catch (...) {
65449       {
65450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65451       };
65452     }
65453   }
65454 }
65455
65456
65457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
65458   void * jresult ;
65459   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65460   Dali::Actor result;
65461
65462   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65463   {
65464     try {
65465       result = (arg1)->GetScrollIndicator();
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65473       };
65474     } catch (...) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65477       };
65478     }
65479   }
65480   jresult = new Dali::Actor((const Dali::Actor &)result);
65481   return jresult;
65482 }
65483
65484
65485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
65486   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65487   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
65488
65489   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65490   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
65491   if (!arg2) {
65492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
65493     return ;
65494   }
65495   {
65496     try {
65497       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
65498     } catch (std::out_of_range& e) {
65499       {
65500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65501       };
65502     } catch (std::exception& e) {
65503       {
65504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65505       };
65506     } catch (...) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65509       };
65510     }
65511   }
65512 }
65513
65514
65515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
65516   void * jresult ;
65517   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65518   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
65519
65520   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65521   {
65522     try {
65523       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65531       };
65532     } catch (...) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65535       };
65536     }
65537   }
65538   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
65539   return jresult;
65540 }
65541
65542
65543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
65544   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65545   Dali::Toolkit::ScrollBar::Direction arg2 ;
65546
65547   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65548   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
65549   {
65550     try {
65551       (arg1)->SetScrollDirection(arg2);
65552     } catch (std::out_of_range& e) {
65553       {
65554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65555       };
65556     } catch (std::exception& e) {
65557       {
65558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65559       };
65560     } catch (...) {
65561       {
65562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65563       };
65564     }
65565   }
65566 }
65567
65568
65569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
65570   int jresult ;
65571   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65572   Dali::Toolkit::ScrollBar::Direction result;
65573
65574   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65575   {
65576     try {
65577       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
65578     } catch (std::out_of_range& e) {
65579       {
65580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65581       };
65582     } catch (std::exception& e) {
65583       {
65584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65585       };
65586     } catch (...) {
65587       {
65588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65589       };
65590     }
65591   }
65592   jresult = (int)result;
65593   return jresult;
65594 }
65595
65596
65597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
65598   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65599   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
65600
65601   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65602   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
65603   {
65604     try {
65605       (arg1)->SetIndicatorHeightPolicy(arg2);
65606     } catch (std::out_of_range& e) {
65607       {
65608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65609       };
65610     } catch (std::exception& e) {
65611       {
65612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65613       };
65614     } catch (...) {
65615       {
65616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65617       };
65618     }
65619   }
65620 }
65621
65622
65623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
65624   int jresult ;
65625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65626   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
65627
65628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65629   {
65630     try {
65631       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
65632     } catch (std::out_of_range& e) {
65633       {
65634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65635       };
65636     } catch (std::exception& e) {
65637       {
65638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (...) {
65641       {
65642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65643       };
65644     }
65645   }
65646   jresult = (int)result;
65647   return jresult;
65648 }
65649
65650
65651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
65652   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65653   float arg2 ;
65654
65655   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65656   arg2 = (float)jarg2;
65657   {
65658     try {
65659       (arg1)->SetIndicatorFixedHeight(arg2);
65660     } catch (std::out_of_range& e) {
65661       {
65662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65663       };
65664     } catch (std::exception& e) {
65665       {
65666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65667       };
65668     } catch (...) {
65669       {
65670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65671       };
65672     }
65673   }
65674 }
65675
65676
65677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
65678   float jresult ;
65679   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65680   float result;
65681
65682   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65683   {
65684     try {
65685       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
65686     } catch (std::out_of_range& e) {
65687       {
65688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65689       };
65690     } catch (std::exception& e) {
65691       {
65692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65693       };
65694     } catch (...) {
65695       {
65696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65697       };
65698     }
65699   }
65700   jresult = result;
65701   return jresult;
65702 }
65703
65704
65705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
65706   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65707   float arg2 ;
65708
65709   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65710   arg2 = (float)jarg2;
65711   {
65712     try {
65713       (arg1)->SetIndicatorShowDuration(arg2);
65714     } catch (std::out_of_range& e) {
65715       {
65716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65717       };
65718     } catch (std::exception& e) {
65719       {
65720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65721       };
65722     } catch (...) {
65723       {
65724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65725       };
65726     }
65727   }
65728 }
65729
65730
65731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
65732   float jresult ;
65733   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65734   float result;
65735
65736   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65737   {
65738     try {
65739       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
65740     } catch (std::out_of_range& e) {
65741       {
65742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65743       };
65744     } catch (std::exception& e) {
65745       {
65746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65747       };
65748     } catch (...) {
65749       {
65750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65751       };
65752     }
65753   }
65754   jresult = result;
65755   return jresult;
65756 }
65757
65758
65759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
65760   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65761   float arg2 ;
65762
65763   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65764   arg2 = (float)jarg2;
65765   {
65766     try {
65767       (arg1)->SetIndicatorHideDuration(arg2);
65768     } catch (std::out_of_range& e) {
65769       {
65770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65771       };
65772     } catch (std::exception& e) {
65773       {
65774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65775       };
65776     } catch (...) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65779       };
65780     }
65781   }
65782 }
65783
65784
65785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
65786   float jresult ;
65787   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65788   float result;
65789
65790   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65791   {
65792     try {
65793       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
65794     } catch (std::out_of_range& e) {
65795       {
65796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65797       };
65798     } catch (std::exception& e) {
65799       {
65800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65801       };
65802     } catch (...) {
65803       {
65804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65805       };
65806     }
65807   }
65808   jresult = result;
65809   return jresult;
65810 }
65811
65812
65813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
65814   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65815
65816   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65817   {
65818     try {
65819       (arg1)->ShowIndicator();
65820     } catch (std::out_of_range& e) {
65821       {
65822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65823       };
65824     } catch (std::exception& e) {
65825       {
65826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65827       };
65828     } catch (...) {
65829       {
65830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65831       };
65832     }
65833   }
65834 }
65835
65836
65837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
65838   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65839
65840   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65841   {
65842     try {
65843       (arg1)->HideIndicator();
65844     } catch (std::out_of_range& e) {
65845       {
65846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65847       };
65848     } catch (std::exception& e) {
65849       {
65850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65851       };
65852     } catch (...) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65855       };
65856     }
65857   }
65858 }
65859
65860
65861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
65862   void * jresult ;
65863   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65864   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
65865
65866   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65867   {
65868     try {
65869       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
65870     } catch (std::out_of_range& e) {
65871       {
65872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65873       };
65874     } catch (std::exception& e) {
65875       {
65876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65877       };
65878     } catch (...) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65881       };
65882     }
65883   }
65884   jresult = (void *)result;
65885   return jresult;
65886 }
65887
65888
65889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
65890   void * jresult ;
65891   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
65892   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
65893
65894   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
65895   {
65896     try {
65897       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
65898     } catch (std::out_of_range& e) {
65899       {
65900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65901       };
65902     } catch (std::exception& e) {
65903       {
65904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65905       };
65906     } catch (...) {
65907       {
65908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65909       };
65910     }
65911   }
65912   jresult = (void *)result;
65913   return jresult;
65914 }
65915
65916
65917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
65918   int jresult ;
65919   int result;
65920
65921   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
65922   jresult = (int)result;
65923   return jresult;
65924 }
65925
65926
65927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
65928   int jresult ;
65929   int result;
65930
65931   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
65932   jresult = (int)result;
65933   return jresult;
65934 }
65935
65936
65937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
65938   int jresult ;
65939   int result;
65940
65941   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
65942   jresult = (int)result;
65943   return jresult;
65944 }
65945
65946
65947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
65948   int jresult ;
65949   int result;
65950
65951   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
65952   jresult = (int)result;
65953   return jresult;
65954 }
65955
65956
65957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
65958   int jresult ;
65959   int result;
65960
65961   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
65962   jresult = (int)result;
65963   return jresult;
65964 }
65965
65966
65967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
65968   int jresult ;
65969   int result;
65970
65971   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
65972   jresult = (int)result;
65973   return jresult;
65974 }
65975
65976
65977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
65978   int jresult ;
65979   int result;
65980
65981   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
65982   jresult = (int)result;
65983   return jresult;
65984 }
65985
65986
65987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
65988   int jresult ;
65989   int result;
65990
65991   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
65992   jresult = (int)result;
65993   return jresult;
65994 }
65995
65996
65997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
65998   int jresult ;
65999   int result;
66000
66001   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
66002   jresult = (int)result;
66003   return jresult;
66004 }
66005
66006
66007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
66008   int jresult ;
66009   int result;
66010
66011   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
66012   jresult = (int)result;
66013   return jresult;
66014 }
66015
66016
66017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
66018   int jresult ;
66019   int result;
66020
66021   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
66022   jresult = (int)result;
66023   return jresult;
66024 }
66025
66026
66027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
66028   int jresult ;
66029   int result;
66030
66031   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
66032   jresult = (int)result;
66033   return jresult;
66034 }
66035
66036
66037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
66038   int jresult ;
66039   int result;
66040
66041   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
66042   jresult = (int)result;
66043   return jresult;
66044 }
66045
66046
66047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
66048   int jresult ;
66049   int result;
66050
66051   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
66052   jresult = (int)result;
66053   return jresult;
66054 }
66055
66056
66057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
66058   void * jresult ;
66059   Dali::Toolkit::Scrollable::Property *result = 0 ;
66060
66061   {
66062     try {
66063       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
66064     } catch (std::out_of_range& e) {
66065       {
66066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66067       };
66068     } catch (std::exception& e) {
66069       {
66070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (...) {
66073       {
66074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66075       };
66076     }
66077   }
66078   jresult = (void *)result;
66079   return jresult;
66080 }
66081
66082
66083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
66084   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
66085
66086   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
66087   {
66088     try {
66089       delete arg1;
66090     } catch (std::out_of_range& e) {
66091       {
66092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66093       };
66094     } catch (std::exception& e) {
66095       {
66096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66097       };
66098     } catch (...) {
66099       {
66100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66101       };
66102     }
66103   }
66104 }
66105
66106
66107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
66108   void * jresult ;
66109   Dali::Toolkit::Scrollable *result = 0 ;
66110
66111   {
66112     try {
66113       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
66114     } catch (std::out_of_range& e) {
66115       {
66116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66117       };
66118     } catch (std::exception& e) {
66119       {
66120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66121       };
66122     } catch (...) {
66123       {
66124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66125       };
66126     }
66127   }
66128   jresult = (void *)result;
66129   return jresult;
66130 }
66131
66132
66133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
66134   void * jresult ;
66135   Dali::Toolkit::Scrollable *arg1 = 0 ;
66136   Dali::Toolkit::Scrollable *result = 0 ;
66137
66138   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66139   if (!arg1) {
66140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66141     return 0;
66142   }
66143   {
66144     try {
66145       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
66146     } catch (std::out_of_range& e) {
66147       {
66148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66149       };
66150     } catch (std::exception& e) {
66151       {
66152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66153       };
66154     } catch (...) {
66155       {
66156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66157       };
66158     }
66159   }
66160   jresult = (void *)result;
66161   return jresult;
66162 }
66163
66164
66165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
66166   void * jresult ;
66167   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66168   Dali::Toolkit::Scrollable *arg2 = 0 ;
66169   Dali::Toolkit::Scrollable *result = 0 ;
66170
66171   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66172   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
66173   if (!arg2) {
66174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
66175     return 0;
66176   }
66177   {
66178     try {
66179       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66187       };
66188     } catch (...) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66191       };
66192     }
66193   }
66194   jresult = (void *)result;
66195   return jresult;
66196 }
66197
66198
66199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
66200   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66201
66202   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66203   {
66204     try {
66205       delete arg1;
66206     } catch (std::out_of_range& e) {
66207       {
66208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66209       };
66210     } catch (std::exception& e) {
66211       {
66212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (...) {
66215       {
66216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66217       };
66218     }
66219   }
66220 }
66221
66222
66223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
66224   void * jresult ;
66225   Dali::BaseHandle arg1 ;
66226   Dali::BaseHandle *argp1 ;
66227   Dali::Toolkit::Scrollable result;
66228
66229   argp1 = (Dali::BaseHandle *)jarg1;
66230   if (!argp1) {
66231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66232     return 0;
66233   }
66234   arg1 = *argp1;
66235   {
66236     try {
66237       result = Dali::Toolkit::Scrollable::DownCast(arg1);
66238     } catch (std::out_of_range& e) {
66239       {
66240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (std::exception& e) {
66243       {
66244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66249       };
66250     }
66251   }
66252   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
66253   return jresult;
66254 }
66255
66256
66257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
66258   unsigned int jresult ;
66259   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66260   bool result;
66261
66262   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66263   {
66264     try {
66265       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
66266     } catch (std::out_of_range& e) {
66267       {
66268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66269       };
66270     } catch (std::exception& e) {
66271       {
66272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66273       };
66274     } catch (...) {
66275       {
66276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66277       };
66278     }
66279   }
66280   jresult = result;
66281   return jresult;
66282 }
66283
66284
66285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
66286   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66287   bool arg2 ;
66288
66289   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66290   arg2 = jarg2 ? true : false;
66291   {
66292     try {
66293       (arg1)->SetOvershootEnabled(arg2);
66294     } catch (std::out_of_range& e) {
66295       {
66296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66297       };
66298     } catch (std::exception& e) {
66299       {
66300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66301       };
66302     } catch (...) {
66303       {
66304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66305       };
66306     }
66307   }
66308 }
66309
66310
66311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
66312   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66313   Dali::Vector4 *arg2 = 0 ;
66314
66315   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66316   arg2 = (Dali::Vector4 *)jarg2;
66317   if (!arg2) {
66318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
66319     return ;
66320   }
66321   {
66322     try {
66323       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
66324     } catch (std::out_of_range& e) {
66325       {
66326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66327       };
66328     } catch (std::exception& e) {
66329       {
66330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66331       };
66332     } catch (...) {
66333       {
66334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66335       };
66336     }
66337   }
66338 }
66339
66340
66341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
66342   void * jresult ;
66343   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66344   Dali::Vector4 result;
66345
66346   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66347   {
66348     try {
66349       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
66350     } catch (std::out_of_range& e) {
66351       {
66352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66353       };
66354     } catch (std::exception& e) {
66355       {
66356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66357       };
66358     } catch (...) {
66359       {
66360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66361       };
66362     }
66363   }
66364   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
66365   return jresult;
66366 }
66367
66368
66369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
66370   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66371   float arg2 ;
66372
66373   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66374   arg2 = (float)jarg2;
66375   {
66376     try {
66377       (arg1)->SetOvershootAnimationSpeed(arg2);
66378     } catch (std::out_of_range& e) {
66379       {
66380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66381       };
66382     } catch (std::exception& e) {
66383       {
66384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66385       };
66386     } catch (...) {
66387       {
66388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66389       };
66390     }
66391   }
66392 }
66393
66394
66395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
66396   float jresult ;
66397   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66398   float result;
66399
66400   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66401   {
66402     try {
66403       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
66404     } catch (std::out_of_range& e) {
66405       {
66406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66407       };
66408     } catch (std::exception& e) {
66409       {
66410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66411       };
66412     } catch (...) {
66413       {
66414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66415       };
66416     }
66417   }
66418   jresult = result;
66419   return jresult;
66420 }
66421
66422
66423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
66424   void * jresult ;
66425   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66426   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
66427
66428   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66429   {
66430     try {
66431       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
66432     } catch (std::out_of_range& e) {
66433       {
66434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66435       };
66436     } catch (std::exception& e) {
66437       {
66438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66439       };
66440     } catch (...) {
66441       {
66442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66443       };
66444     }
66445   }
66446   jresult = (void *)result;
66447   return jresult;
66448 }
66449
66450
66451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
66452   void * jresult ;
66453   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66454   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
66455
66456   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66457   {
66458     try {
66459       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
66460     } catch (std::out_of_range& e) {
66461       {
66462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66463       };
66464     } catch (std::exception& e) {
66465       {
66466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66467       };
66468     } catch (...) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66471       };
66472     }
66473   }
66474   jresult = (void *)result;
66475   return jresult;
66476 }
66477
66478
66479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
66480   void * jresult ;
66481   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
66482   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
66483
66484   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
66485   {
66486     try {
66487       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
66488     } catch (std::out_of_range& e) {
66489       {
66490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (std::exception& e) {
66493       {
66494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66495       };
66496     } catch (...) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66499       };
66500     }
66501   }
66502   jresult = (void *)result;
66503   return jresult;
66504 }
66505
66506
66507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
66508   unsigned int jresult ;
66509   Dali::Toolkit::ControlOrientation::Type arg1 ;
66510   bool result;
66511
66512   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66513   {
66514     try {
66515       result = (bool)Dali::Toolkit::IsVertical(arg1);
66516     } catch (std::out_of_range& e) {
66517       {
66518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66519       };
66520     } catch (std::exception& e) {
66521       {
66522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66523       };
66524     } catch (...) {
66525       {
66526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66527       };
66528     }
66529   }
66530   jresult = result;
66531   return jresult;
66532 }
66533
66534
66535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
66536   unsigned int jresult ;
66537   Dali::Toolkit::ControlOrientation::Type arg1 ;
66538   bool result;
66539
66540   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
66541   {
66542     try {
66543       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
66544     } catch (std::out_of_range& e) {
66545       {
66546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66547       };
66548     } catch (std::exception& e) {
66549       {
66550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66551       };
66552     } catch (...) {
66553       {
66554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66555       };
66556     }
66557   }
66558   jresult = result;
66559   return jresult;
66560 }
66561
66562
66563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
66564   void * jresult ;
66565   unsigned int arg1 ;
66566   unsigned int arg2 ;
66567   Dali::Toolkit::ItemRange *result = 0 ;
66568
66569   arg1 = (unsigned int)jarg1;
66570   arg2 = (unsigned int)jarg2;
66571   {
66572     try {
66573       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
66574     } catch (std::out_of_range& e) {
66575       {
66576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66577       };
66578     } catch (std::exception& e) {
66579       {
66580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66581       };
66582     } catch (...) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66585       };
66586     }
66587   }
66588   jresult = (void *)result;
66589   return jresult;
66590 }
66591
66592
66593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
66594   void * jresult ;
66595   Dali::Toolkit::ItemRange *arg1 = 0 ;
66596   Dali::Toolkit::ItemRange *result = 0 ;
66597
66598   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66599   if (!arg1) {
66600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66601     return 0;
66602   }
66603   {
66604     try {
66605       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66613       };
66614     } catch (...) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66617       };
66618     }
66619   }
66620   jresult = (void *)result;
66621   return jresult;
66622 }
66623
66624
66625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
66626   void * jresult ;
66627   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66628   Dali::Toolkit::ItemRange *arg2 = 0 ;
66629   Dali::Toolkit::ItemRange *result = 0 ;
66630
66631   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66632   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66633   if (!arg2) {
66634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66635     return 0;
66636   }
66637   {
66638     try {
66639       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (...) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66651       };
66652     }
66653   }
66654   jresult = (void *)result;
66655   return jresult;
66656 }
66657
66658
66659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
66660   unsigned int jresult ;
66661   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66662   unsigned int arg2 ;
66663   bool result;
66664
66665   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66666   arg2 = (unsigned int)jarg2;
66667   {
66668     try {
66669       result = (bool)(arg1)->Within(arg2);
66670     } catch (std::out_of_range& e) {
66671       {
66672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66673       };
66674     } catch (std::exception& e) {
66675       {
66676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66677       };
66678     } catch (...) {
66679       {
66680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66681       };
66682     }
66683   }
66684   jresult = result;
66685   return jresult;
66686 }
66687
66688
66689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
66690   void * jresult ;
66691   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66692   Dali::Toolkit::ItemRange *arg2 = 0 ;
66693   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
66694
66695   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66696   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
66697   if (!arg2) {
66698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
66699     return 0;
66700   }
66701   {
66702     try {
66703       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
66704     } catch (std::out_of_range& e) {
66705       {
66706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66707       };
66708     } catch (std::exception& e) {
66709       {
66710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66711       };
66712     } catch (...) {
66713       {
66714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66715       };
66716     }
66717   }
66718   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
66719   return jresult;
66720 }
66721
66722
66723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
66724   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66725   unsigned int arg2 ;
66726
66727   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66728   arg2 = (unsigned int)jarg2;
66729   if (arg1) (arg1)->begin = arg2;
66730 }
66731
66732
66733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
66734   unsigned int jresult ;
66735   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66736   unsigned int result;
66737
66738   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66739   result = (unsigned int) ((arg1)->begin);
66740   jresult = result;
66741   return jresult;
66742 }
66743
66744
66745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
66746   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66747   unsigned int arg2 ;
66748
66749   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66750   arg2 = (unsigned int)jarg2;
66751   if (arg1) (arg1)->end = arg2;
66752 }
66753
66754
66755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
66756   unsigned int jresult ;
66757   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66758   unsigned int result;
66759
66760   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66761   result = (unsigned int) ((arg1)->end);
66762   jresult = result;
66763   return jresult;
66764 }
66765
66766
66767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
66768   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
66769
66770   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
66771   {
66772     try {
66773       delete arg1;
66774     } catch (std::out_of_range& e) {
66775       {
66776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66777       };
66778     } catch (std::exception& e) {
66779       {
66780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66781       };
66782     } catch (...) {
66783       {
66784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66785       };
66786     }
66787   }
66788 }
66789
66790
66791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
66792   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66793
66794   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66795   {
66796     try {
66797       delete arg1;
66798     } catch (std::out_of_range& e) {
66799       {
66800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66801       };
66802     } catch (std::exception& e) {
66803       {
66804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66805       };
66806     } catch (...) {
66807       {
66808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66809       };
66810     }
66811   }
66812 }
66813
66814
66815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
66816   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66817   Dali::Toolkit::ControlOrientation::Type arg2 ;
66818
66819   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66820   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
66821   {
66822     try {
66823       (arg1)->SetOrientation(arg2);
66824     } catch (std::out_of_range& e) {
66825       {
66826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66827       };
66828     } catch (std::exception& e) {
66829       {
66830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66831       };
66832     } catch (...) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66835       };
66836     }
66837   }
66838 }
66839
66840
66841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
66842   int jresult ;
66843   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66844   Dali::Toolkit::ControlOrientation::Type result;
66845
66846   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66847   {
66848     try {
66849       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
66850     } catch (std::out_of_range& e) {
66851       {
66852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66853       };
66854     } catch (std::exception& e) {
66855       {
66856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66857       };
66858     } catch (...) {
66859       {
66860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66861       };
66862     }
66863   }
66864   jresult = (int)result;
66865   return jresult;
66866 }
66867
66868
66869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
66870   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66871   Dali::Property::Map *arg2 = 0 ;
66872
66873   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66874   arg2 = (Dali::Property::Map *)jarg2;
66875   if (!arg2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
66877     return ;
66878   }
66879   {
66880     try {
66881       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
66882     } catch (std::out_of_range& e) {
66883       {
66884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66885       };
66886     } catch (std::exception& e) {
66887       {
66888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66889       };
66890     } catch (...) {
66891       {
66892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66893       };
66894     }
66895   }
66896 }
66897
66898
66899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
66900   void * jresult ;
66901   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66902   Dali::Property::Map result;
66903
66904   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66905   {
66906     try {
66907       result = (arg1)->GetLayoutProperties();
66908     } catch (std::out_of_range& e) {
66909       {
66910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66911       };
66912     } catch (std::exception& e) {
66913       {
66914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66915       };
66916     } catch (...) {
66917       {
66918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66919       };
66920     }
66921   }
66922   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
66923   return jresult;
66924 }
66925
66926
66927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
66928   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66929   unsigned int arg2 ;
66930   Dali::Vector3 *arg3 = 0 ;
66931   Dali::Vector3 *arg4 = 0 ;
66932
66933   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66934   arg2 = (unsigned int)jarg2;
66935   arg3 = (Dali::Vector3 *)jarg3;
66936   if (!arg3) {
66937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66938     return ;
66939   }
66940   arg4 = (Dali::Vector3 *)jarg4;
66941   if (!arg4) {
66942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
66943     return ;
66944   }
66945   {
66946     try {
66947       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
66948     } catch (std::out_of_range& e) {
66949       {
66950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66951       };
66952     } catch (std::exception& e) {
66953       {
66954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66955       };
66956     } catch (...) {
66957       {
66958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66959       };
66960     }
66961   }
66962 }
66963
66964
66965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
66966   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66967   Dali::Vector3 *arg2 = 0 ;
66968
66969   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
66970   arg2 = (Dali::Vector3 *)jarg2;
66971   if (!arg2) {
66972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
66973     return ;
66974   }
66975   {
66976     try {
66977       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
66978     } catch (std::out_of_range& e) {
66979       {
66980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66981       };
66982     } catch (std::exception& e) {
66983       {
66984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66985       };
66986     } catch (...) {
66987       {
66988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66989       };
66990     }
66991   }
66992 }
66993
66994
66995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
66996   float jresult ;
66997   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
66998   unsigned int arg2 ;
66999   Dali::Vector3 arg3 ;
67000   Dali::Vector3 *argp3 ;
67001   float result;
67002
67003   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67004   arg2 = (unsigned int)jarg2;
67005   argp3 = (Dali::Vector3 *)jarg3;
67006   if (!argp3) {
67007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67008     return 0;
67009   }
67010   arg3 = *argp3;
67011   {
67012     try {
67013       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
67014     } catch (std::out_of_range& e) {
67015       {
67016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67017       };
67018     } catch (std::exception& e) {
67019       {
67020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67025       };
67026     }
67027   }
67028   jresult = result;
67029   return jresult;
67030 }
67031
67032
67033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
67034   float jresult ;
67035   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67036   float arg2 ;
67037   float result;
67038
67039   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67040   arg2 = (float)jarg2;
67041   {
67042     try {
67043       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
67044     } catch (std::out_of_range& e) {
67045       {
67046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67047       };
67048     } catch (std::exception& e) {
67049       {
67050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67051       };
67052     } catch (...) {
67053       {
67054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67055       };
67056     }
67057   }
67058   jresult = result;
67059   return jresult;
67060 }
67061
67062
67063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
67064   float jresult ;
67065   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67066   unsigned int arg2 ;
67067   float result;
67068
67069   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67070   arg2 = (unsigned int)jarg2;
67071   {
67072     try {
67073       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67081       };
67082     } catch (...) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67085       };
67086     }
67087   }
67088   jresult = result;
67089   return jresult;
67090 }
67091
67092
67093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
67094   void * jresult ;
67095   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67096   float arg2 ;
67097   Dali::Vector3 arg3 ;
67098   Dali::Vector3 *argp3 ;
67099   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
67100
67101   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67102   arg2 = (float)jarg2;
67103   argp3 = (Dali::Vector3 *)jarg3;
67104   if (!argp3) {
67105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67106     return 0;
67107   }
67108   arg3 = *argp3;
67109   {
67110     try {
67111       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
67112     } catch (std::out_of_range& e) {
67113       {
67114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67115       };
67116     } catch (std::exception& e) {
67117       {
67118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67119       };
67120     } catch (...) {
67121       {
67122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67123       };
67124     }
67125   }
67126   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
67127   return jresult;
67128 }
67129
67130
67131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67132   float jresult ;
67133   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67134   int arg2 ;
67135   float arg3 ;
67136   Dali::Vector3 *arg4 = 0 ;
67137   float result;
67138
67139   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67140   arg2 = (int)jarg2;
67141   arg3 = (float)jarg3;
67142   arg4 = (Dali::Vector3 *)jarg4;
67143   if (!arg4) {
67144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67145     return 0;
67146   }
67147   {
67148     try {
67149       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67150     } catch (std::out_of_range& e) {
67151       {
67152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67153       };
67154     } catch (std::exception& e) {
67155       {
67156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67157       };
67158     } catch (...) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67161       };
67162     }
67163   }
67164   jresult = result;
67165   return jresult;
67166 }
67167
67168
67169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
67170   unsigned int jresult ;
67171   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67172   Dali::Vector3 arg2 ;
67173   Dali::Vector3 *argp2 ;
67174   unsigned int result;
67175
67176   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67177   argp2 = (Dali::Vector3 *)jarg2;
67178   if (!argp2) {
67179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
67180     return 0;
67181   }
67182   arg2 = *argp2;
67183   {
67184     try {
67185       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
67186     } catch (std::out_of_range& e) {
67187       {
67188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67189       };
67190     } catch (std::exception& e) {
67191       {
67192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67193       };
67194     } catch (...) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67197       };
67198     }
67199   }
67200   jresult = result;
67201   return jresult;
67202 }
67203
67204
67205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
67206   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67207   unsigned int arg2 ;
67208   Dali::Vector3 *arg3 = 0 ;
67209   Dali::Vector3 *arg4 = 0 ;
67210
67211   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67212   arg2 = (unsigned int)jarg2;
67213   arg3 = (Dali::Vector3 *)jarg3;
67214   if (!arg3) {
67215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67216     return ;
67217   }
67218   arg4 = (Dali::Vector3 *)jarg4;
67219   if (!arg4) {
67220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
67221     return ;
67222   }
67223   {
67224     try {
67225       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
67226     } catch (std::out_of_range& e) {
67227       {
67228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67229       };
67230     } catch (std::exception& e) {
67231       {
67232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67233       };
67234     } catch (...) {
67235       {
67236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67237       };
67238     }
67239   }
67240 }
67241
67242
67243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
67244   void * jresult ;
67245   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67246   Dali::Degree result;
67247
67248   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67249   {
67250     try {
67251       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
67252     } catch (std::out_of_range& e) {
67253       {
67254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67255       };
67256     } catch (std::exception& e) {
67257       {
67258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67259       };
67260     } catch (...) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67263       };
67264     }
67265   }
67266   jresult = new Dali::Degree((const Dali::Degree &)result);
67267   return jresult;
67268 }
67269
67270
67271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
67272   float jresult ;
67273   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67274   float result;
67275
67276   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67277   {
67278     try {
67279       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
67280     } catch (std::out_of_range& e) {
67281       {
67282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67283       };
67284     } catch (std::exception& e) {
67285       {
67286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67287       };
67288     } catch (...) {
67289       {
67290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67291       };
67292     }
67293   }
67294   jresult = result;
67295   return jresult;
67296 }
67297
67298
67299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
67300   float jresult ;
67301   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67302   float result;
67303
67304   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67305   {
67306     try {
67307       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
67308     } catch (std::out_of_range& e) {
67309       {
67310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67311       };
67312     } catch (std::exception& e) {
67313       {
67314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67315       };
67316     } catch (...) {
67317       {
67318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67319       };
67320     }
67321   }
67322   jresult = result;
67323   return jresult;
67324 }
67325
67326
67327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
67328   float jresult ;
67329   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67330   float result;
67331
67332   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67333   {
67334     try {
67335       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
67336     } catch (std::out_of_range& e) {
67337       {
67338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (std::exception& e) {
67341       {
67342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (...) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67347       };
67348     }
67349   }
67350   jresult = result;
67351   return jresult;
67352 }
67353
67354
67355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
67356   int jresult ;
67357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67358   int arg2 ;
67359   int arg3 ;
67360   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
67361   bool arg5 ;
67362   int result;
67363
67364   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67365   arg2 = (int)jarg2;
67366   arg3 = (int)jarg3;
67367   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
67368   arg5 = jarg5 ? true : false;
67369   {
67370     try {
67371       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
67372     } catch (std::out_of_range& e) {
67373       {
67374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67375       };
67376     } catch (std::exception& e) {
67377       {
67378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67379       };
67380     } catch (...) {
67381       {
67382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67383       };
67384     }
67385   }
67386   jresult = result;
67387   return jresult;
67388 }
67389
67390
67391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
67392   float jresult ;
67393   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67394   float result;
67395
67396   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67397   {
67398     try {
67399       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
67400     } catch (std::out_of_range& e) {
67401       {
67402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (std::exception& e) {
67405       {
67406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67407       };
67408     } catch (...) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67411       };
67412     }
67413   }
67414   jresult = result;
67415   return jresult;
67416 }
67417
67418
67419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
67420   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67421   Dali::Actor *arg2 = 0 ;
67422   int arg3 ;
67423   Dali::Vector3 *arg4 = 0 ;
67424   Dali::Actor *arg5 = 0 ;
67425
67426   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67427   arg2 = (Dali::Actor *)jarg2;
67428   if (!arg2) {
67429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
67430     return ;
67431   }
67432   arg3 = (int)jarg3;
67433   arg4 = (Dali::Vector3 *)jarg4;
67434   if (!arg4) {
67435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67436     return ;
67437   }
67438   arg5 = (Dali::Actor *)jarg5;
67439   if (!arg5) {
67440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
67441     return ;
67442   }
67443   {
67444     try {
67445       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67457       };
67458     }
67459   }
67460 }
67461
67462
67463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
67464   void * jresult ;
67465   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
67466   int arg2 ;
67467   float arg3 ;
67468   Dali::Vector3 *arg4 = 0 ;
67469   Dali::Vector3 result;
67470
67471   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
67472   arg2 = (int)jarg2;
67473   arg3 = (float)jarg3;
67474   arg4 = (Dali::Vector3 *)jarg4;
67475   if (!arg4) {
67476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
67477     return 0;
67478   }
67479   {
67480     try {
67481       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
67482     } catch (std::out_of_range& e) {
67483       {
67484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67485       };
67486     } catch (std::exception& e) {
67487       {
67488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67489       };
67490     } catch (...) {
67491       {
67492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67493       };
67494     }
67495   }
67496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
67497   return jresult;
67498 }
67499
67500
67501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
67502   void * jresult ;
67503   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
67504   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
67505
67506   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
67507   {
67508     try {
67509       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
67510     } catch (std::out_of_range& e) {
67511       {
67512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67513       };
67514     } catch (std::exception& e) {
67515       {
67516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67517       };
67518     } catch (...) {
67519       {
67520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67521       };
67522     }
67523   }
67524   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
67525   return jresult;
67526 }
67527
67528
67529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
67530   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67531
67532   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67533   {
67534     try {
67535       delete arg1;
67536     } catch (std::out_of_range& e) {
67537       {
67538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67539       };
67540     } catch (std::exception& e) {
67541       {
67542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67547       };
67548     }
67549   }
67550 }
67551
67552
67553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
67554   unsigned int jresult ;
67555   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67556   unsigned int result;
67557
67558   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67559   {
67560     try {
67561       result = (unsigned int)(arg1)->GetNumberOfItems();
67562     } catch (std::out_of_range& e) {
67563       {
67564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67565       };
67566     } catch (std::exception& e) {
67567       {
67568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67569       };
67570     } catch (...) {
67571       {
67572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67573       };
67574     }
67575   }
67576   jresult = result;
67577   return jresult;
67578 }
67579
67580
67581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
67582   void * jresult ;
67583   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67584   unsigned int arg2 ;
67585   Dali::Actor result;
67586
67587   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67588   arg2 = (unsigned int)jarg2;
67589   {
67590     try {
67591       result = (arg1)->NewItem(arg2);
67592     } catch (std::out_of_range& e) {
67593       {
67594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67595       };
67596     } catch (std::exception& e) {
67597       {
67598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67599       };
67600     } catch (...) {
67601       {
67602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67603       };
67604     }
67605   }
67606   jresult = new Dali::Actor((const Dali::Actor &)result);
67607   return jresult;
67608 }
67609
67610
67611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
67612   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67613   unsigned int arg2 ;
67614   Dali::Actor arg3 ;
67615   Dali::Actor *argp3 ;
67616
67617   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67618   arg2 = (unsigned int)jarg2;
67619   argp3 = (Dali::Actor *)jarg3;
67620   if (!argp3) {
67621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67622     return ;
67623   }
67624   arg3 = *argp3;
67625   {
67626     try {
67627       (arg1)->ItemReleased(arg2,arg3);
67628     } catch (std::out_of_range& e) {
67629       {
67630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67631       };
67632     } catch (std::exception& e) {
67633       {
67634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67635       };
67636     } catch (...) {
67637       {
67638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67639       };
67640     }
67641   }
67642 }
67643
67644
67645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
67646   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
67647   unsigned int arg2 ;
67648   Dali::Actor arg3 ;
67649   Dali::Actor *argp3 ;
67650
67651   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67652   arg2 = (unsigned int)jarg2;
67653   argp3 = (Dali::Actor *)jarg3;
67654   if (!argp3) {
67655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67656     return ;
67657   }
67658   arg3 = *argp3;
67659   {
67660     try {
67661       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
67662     } catch (std::out_of_range& e) {
67663       {
67664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67665       };
67666     } catch (std::exception& e) {
67667       {
67668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67669       };
67670     } catch (...) {
67671       {
67672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67673       };
67674     }
67675   }
67676 }
67677
67678
67679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
67680   void * jresult ;
67681   Dali::Toolkit::ItemFactory *result = 0 ;
67682
67683   {
67684     try {
67685       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
67686     } catch (std::out_of_range& e) {
67687       {
67688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (std::exception& e) {
67691       {
67692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (...) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67697       };
67698     }
67699   }
67700   jresult = (void *)result;
67701   return jresult;
67702 }
67703
67704
67705 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) {
67706   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
67707   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
67708   if (director) {
67709     director->swig_connect_director(callback0, callback1, callback2);
67710   }
67711 }
67712
67713
67714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
67715   int jresult ;
67716   int result;
67717
67718   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
67719   jresult = (int)result;
67720   return jresult;
67721 }
67722
67723
67724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
67725   int jresult ;
67726   int result;
67727
67728   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
67729   jresult = (int)result;
67730   return jresult;
67731 }
67732
67733
67734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
67735   int jresult ;
67736   int result;
67737
67738   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
67739   jresult = (int)result;
67740   return jresult;
67741 }
67742
67743
67744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
67745   int jresult ;
67746   int result;
67747
67748   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
67749   jresult = (int)result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
67755   int jresult ;
67756   int result;
67757
67758   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
67759   jresult = (int)result;
67760   return jresult;
67761 }
67762
67763
67764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
67765   int jresult ;
67766   int result;
67767
67768   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
67769   jresult = (int)result;
67770   return jresult;
67771 }
67772
67773
67774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
67775   int jresult ;
67776   int result;
67777
67778   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
67779   jresult = (int)result;
67780   return jresult;
67781 }
67782
67783
67784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
67785   int jresult ;
67786   int result;
67787
67788   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
67789   jresult = (int)result;
67790   return jresult;
67791 }
67792
67793
67794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
67795   int jresult ;
67796   int result;
67797
67798   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
67799   jresult = (int)result;
67800   return jresult;
67801 }
67802
67803
67804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
67805   int jresult ;
67806   int result;
67807
67808   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
67809   jresult = (int)result;
67810   return jresult;
67811 }
67812
67813
67814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
67815   int jresult ;
67816   int result;
67817
67818   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
67819   jresult = (int)result;
67820   return jresult;
67821 }
67822
67823
67824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
67825   void * jresult ;
67826   Dali::Toolkit::ItemView::Property *result = 0 ;
67827
67828   {
67829     try {
67830       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
67831     } catch (std::out_of_range& e) {
67832       {
67833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67834       };
67835     } catch (std::exception& e) {
67836       {
67837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67838       };
67839     } catch (...) {
67840       {
67841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67842       };
67843     }
67844   }
67845   jresult = (void *)result;
67846   return jresult;
67847 }
67848
67849
67850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
67851   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
67852
67853   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
67854   {
67855     try {
67856       delete arg1;
67857     } catch (std::out_of_range& e) {
67858       {
67859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67860       };
67861     } catch (std::exception& e) {
67862       {
67863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67864       };
67865     } catch (...) {
67866       {
67867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67868       };
67869     }
67870   }
67871 }
67872
67873
67874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
67875   void * jresult ;
67876   Dali::Toolkit::ItemView *result = 0 ;
67877
67878   {
67879     try {
67880       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
67881     } catch (std::out_of_range& e) {
67882       {
67883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67884       };
67885     } catch (std::exception& e) {
67886       {
67887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67888       };
67889     } catch (...) {
67890       {
67891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67892       };
67893     }
67894   }
67895   jresult = (void *)result;
67896   return jresult;
67897 }
67898
67899
67900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
67901   void * jresult ;
67902   Dali::Toolkit::ItemView *arg1 = 0 ;
67903   Dali::Toolkit::ItemView *result = 0 ;
67904
67905   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67906   if (!arg1) {
67907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67908     return 0;
67909   }
67910   {
67911     try {
67912       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
67913     } catch (std::out_of_range& e) {
67914       {
67915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67916       };
67917     } catch (std::exception& e) {
67918       {
67919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67920       };
67921     } catch (...) {
67922       {
67923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67924       };
67925     }
67926   }
67927   jresult = (void *)result;
67928   return jresult;
67929 }
67930
67931
67932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
67933   void * jresult ;
67934   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67935   Dali::Toolkit::ItemView *arg2 = 0 ;
67936   Dali::Toolkit::ItemView *result = 0 ;
67937
67938   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67939   arg2 = (Dali::Toolkit::ItemView *)jarg2;
67940   if (!arg2) {
67941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
67942     return 0;
67943   }
67944   {
67945     try {
67946       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
67947     } catch (std::out_of_range& e) {
67948       {
67949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67950       };
67951     } catch (std::exception& e) {
67952       {
67953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67954       };
67955     } catch (...) {
67956       {
67957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67958       };
67959     }
67960   }
67961   jresult = (void *)result;
67962   return jresult;
67963 }
67964
67965
67966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
67967   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
67968
67969   arg1 = (Dali::Toolkit::ItemView *)jarg1;
67970   {
67971     try {
67972       delete arg1;
67973     } catch (std::out_of_range& e) {
67974       {
67975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67976       };
67977     } catch (std::exception& e) {
67978       {
67979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67980       };
67981     } catch (...) {
67982       {
67983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67984       };
67985     }
67986   }
67987 }
67988
67989
67990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
67991   void * jresult ;
67992   Dali::Toolkit::ItemFactory *arg1 = 0 ;
67993   Dali::Toolkit::ItemView result;
67994
67995   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
67996   if (!arg1) {
67997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
67998     return 0;
67999   }
68000   {
68001     try {
68002       result = Dali::Toolkit::ItemView::New(*arg1);
68003     } catch (std::out_of_range& e) {
68004       {
68005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68006       };
68007     } catch (std::exception& e) {
68008       {
68009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68010       };
68011     } catch (...) {
68012       {
68013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68014       };
68015     }
68016   }
68017   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
68018   return jresult;
68019 }
68020
68021
68022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
68023   void * jresult ;
68024   Dali::BaseHandle arg1 ;
68025   Dali::BaseHandle *argp1 ;
68026   Dali::Toolkit::ItemView result;
68027
68028   argp1 = (Dali::BaseHandle *)jarg1;
68029   if (!argp1) {
68030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68031     return 0;
68032   }
68033   arg1 = *argp1;
68034   {
68035     try {
68036       result = Dali::Toolkit::ItemView::DownCast(arg1);
68037     } catch (std::out_of_range& e) {
68038       {
68039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68040       };
68041     } catch (std::exception& e) {
68042       {
68043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68044       };
68045     } catch (...) {
68046       {
68047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68048       };
68049     }
68050   }
68051   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
68052   return jresult;
68053 }
68054
68055
68056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
68057   unsigned int jresult ;
68058   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68059   unsigned int result;
68060
68061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68062   {
68063     try {
68064       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
68065     } catch (std::out_of_range& e) {
68066       {
68067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68068       };
68069     } catch (std::exception& e) {
68070       {
68071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68072       };
68073     } catch (...) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68076       };
68077     }
68078   }
68079   jresult = result;
68080   return jresult;
68081 }
68082
68083
68084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
68085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68086   Dali::Toolkit::ItemLayout *arg2 = 0 ;
68087
68088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68089   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
68090   if (!arg2) {
68091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
68092     return ;
68093   }
68094   {
68095     try {
68096       (arg1)->AddLayout(*arg2);
68097     } catch (std::out_of_range& e) {
68098       {
68099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68100       };
68101     } catch (std::exception& e) {
68102       {
68103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68104       };
68105     } catch (...) {
68106       {
68107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68108       };
68109     }
68110   }
68111 }
68112
68113
68114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
68115   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68116   unsigned int arg2 ;
68117
68118   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68119   arg2 = (unsigned int)jarg2;
68120   {
68121     try {
68122       (arg1)->RemoveLayout(arg2);
68123     } catch (std::out_of_range& e) {
68124       {
68125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68126       };
68127     } catch (std::exception& e) {
68128       {
68129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68130       };
68131     } catch (...) {
68132       {
68133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68134       };
68135     }
68136   }
68137 }
68138
68139
68140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
68141   void * jresult ;
68142   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68143   unsigned int arg2 ;
68144   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68145
68146   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68147   arg2 = (unsigned int)jarg2;
68148   {
68149     try {
68150       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
68151     } catch (std::out_of_range& e) {
68152       {
68153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68154       };
68155     } catch (std::exception& e) {
68156       {
68157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68158       };
68159     } catch (...) {
68160       {
68161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68162       };
68163     }
68164   }
68165   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68166   return jresult;
68167 }
68168
68169
68170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
68171   void * jresult ;
68172   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68173   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68174
68175   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68176   {
68177     try {
68178       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
68179     } catch (std::out_of_range& e) {
68180       {
68181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68182       };
68183     } catch (std::exception& e) {
68184       {
68185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68186       };
68187     } catch (...) {
68188       {
68189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68190       };
68191     }
68192   }
68193   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68194   return jresult;
68195 }
68196
68197
68198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
68199   float jresult ;
68200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68201   Dali::Toolkit::ItemId arg2 ;
68202   float result;
68203
68204   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68205   arg2 = (Dali::Toolkit::ItemId)jarg2;
68206   {
68207     try {
68208       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
68209     } catch (std::out_of_range& e) {
68210       {
68211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68212       };
68213     } catch (std::exception& e) {
68214       {
68215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68216       };
68217     } catch (...) {
68218       {
68219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68220       };
68221     }
68222   }
68223   jresult = result;
68224   return jresult;
68225 }
68226
68227
68228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
68229   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68230   unsigned int arg2 ;
68231   Dali::Vector3 arg3 ;
68232   float arg4 ;
68233   Dali::Vector3 *argp3 ;
68234
68235   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68236   arg2 = (unsigned int)jarg2;
68237   argp3 = (Dali::Vector3 *)jarg3;
68238   if (!argp3) {
68239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68240     return ;
68241   }
68242   arg3 = *argp3;
68243   arg4 = (float)jarg4;
68244   {
68245     try {
68246       (arg1)->ActivateLayout(arg2,arg3,arg4);
68247     } catch (std::out_of_range& e) {
68248       {
68249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68250       };
68251     } catch (std::exception& e) {
68252       {
68253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68254       };
68255     } catch (...) {
68256       {
68257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68258       };
68259     }
68260   }
68261 }
68262
68263
68264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
68265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68266
68267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68268   {
68269     try {
68270       (arg1)->DeactivateCurrentLayout();
68271     } catch (std::out_of_range& e) {
68272       {
68273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68274       };
68275     } catch (std::exception& e) {
68276       {
68277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68278       };
68279     } catch (...) {
68280       {
68281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68282       };
68283     }
68284   }
68285 }
68286
68287
68288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
68289   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68290   float arg2 ;
68291
68292   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68293   arg2 = (float)jarg2;
68294   {
68295     try {
68296       (arg1)->SetMinimumSwipeSpeed(arg2);
68297     } catch (std::out_of_range& e) {
68298       {
68299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68300       };
68301     } catch (std::exception& e) {
68302       {
68303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68304       };
68305     } catch (...) {
68306       {
68307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68308       };
68309     }
68310   }
68311 }
68312
68313
68314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
68315   float jresult ;
68316   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68317   float result;
68318
68319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68320   {
68321     try {
68322       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
68323     } catch (std::out_of_range& e) {
68324       {
68325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68326       };
68327     } catch (std::exception& e) {
68328       {
68329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (...) {
68332       {
68333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68334       };
68335     }
68336   }
68337   jresult = result;
68338   return jresult;
68339 }
68340
68341
68342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
68343   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68344   float arg2 ;
68345
68346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68347   arg2 = (float)jarg2;
68348   {
68349     try {
68350       (arg1)->SetMinimumSwipeDistance(arg2);
68351     } catch (std::out_of_range& e) {
68352       {
68353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68354       };
68355     } catch (std::exception& e) {
68356       {
68357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68358       };
68359     } catch (...) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68362       };
68363     }
68364   }
68365 }
68366
68367
68368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
68369   float jresult ;
68370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68371   float result;
68372
68373   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68374   {
68375     try {
68376       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
68377     } catch (std::out_of_range& e) {
68378       {
68379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68380       };
68381     } catch (std::exception& e) {
68382       {
68383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68384       };
68385     } catch (...) {
68386       {
68387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68388       };
68389     }
68390   }
68391   jresult = result;
68392   return jresult;
68393 }
68394
68395
68396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
68397   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68398   float arg2 ;
68399
68400   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68401   arg2 = (float)jarg2;
68402   {
68403     try {
68404       (arg1)->SetWheelScrollDistanceStep(arg2);
68405     } catch (std::out_of_range& e) {
68406       {
68407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68408       };
68409     } catch (std::exception& e) {
68410       {
68411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68412       };
68413     } catch (...) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68416       };
68417     }
68418   }
68419 }
68420
68421
68422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
68423   float jresult ;
68424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68425   float result;
68426
68427   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68428   {
68429     try {
68430       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
68431     } catch (std::out_of_range& e) {
68432       {
68433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (std::exception& e) {
68436       {
68437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68438       };
68439     } catch (...) {
68440       {
68441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68442       };
68443     }
68444   }
68445   jresult = result;
68446   return jresult;
68447 }
68448
68449
68450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
68451   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68452   bool arg2 ;
68453
68454   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68455   arg2 = jarg2 ? true : false;
68456   {
68457     try {
68458       (arg1)->SetAnchoring(arg2);
68459     } catch (std::out_of_range& e) {
68460       {
68461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68462       };
68463     } catch (std::exception& e) {
68464       {
68465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68466       };
68467     } catch (...) {
68468       {
68469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68470       };
68471     }
68472   }
68473 }
68474
68475
68476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
68477   unsigned int jresult ;
68478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68479   bool result;
68480
68481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68482   {
68483     try {
68484       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
68485     } catch (std::out_of_range& e) {
68486       {
68487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68488       };
68489     } catch (std::exception& e) {
68490       {
68491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68492       };
68493     } catch (...) {
68494       {
68495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68496       };
68497     }
68498   }
68499   jresult = result;
68500   return jresult;
68501 }
68502
68503
68504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
68505   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68506   float arg2 ;
68507
68508   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68509   arg2 = (float)jarg2;
68510   {
68511     try {
68512       (arg1)->SetAnchoringDuration(arg2);
68513     } catch (std::out_of_range& e) {
68514       {
68515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68516       };
68517     } catch (std::exception& e) {
68518       {
68519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68520       };
68521     } catch (...) {
68522       {
68523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68524       };
68525     }
68526   }
68527 }
68528
68529
68530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
68531   float jresult ;
68532   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68533   float result;
68534
68535   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68536   {
68537     try {
68538       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
68539     } catch (std::out_of_range& e) {
68540       {
68541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68542       };
68543     } catch (std::exception& e) {
68544       {
68545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68546       };
68547     } catch (...) {
68548       {
68549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68550       };
68551     }
68552   }
68553   jresult = result;
68554   return jresult;
68555 }
68556
68557
68558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
68559   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68560   Dali::Toolkit::ItemId arg2 ;
68561   float arg3 ;
68562
68563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68564   arg2 = (Dali::Toolkit::ItemId)jarg2;
68565   arg3 = (float)jarg3;
68566   {
68567     try {
68568       (arg1)->ScrollToItem(arg2,arg3);
68569     } catch (std::out_of_range& e) {
68570       {
68571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68572       };
68573     } catch (std::exception& e) {
68574       {
68575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68576       };
68577     } catch (...) {
68578       {
68579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68580       };
68581     }
68582   }
68583 }
68584
68585
68586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
68587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68588   float arg2 ;
68589
68590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68591   arg2 = (float)jarg2;
68592   {
68593     try {
68594       (arg1)->SetRefreshInterval(arg2);
68595     } catch (std::out_of_range& e) {
68596       {
68597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68598       };
68599     } catch (std::exception& e) {
68600       {
68601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68602       };
68603     } catch (...) {
68604       {
68605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68606       };
68607     }
68608   }
68609 }
68610
68611
68612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
68613   float jresult ;
68614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68615   float result;
68616
68617   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68618   {
68619     try {
68620       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
68621     } catch (std::out_of_range& e) {
68622       {
68623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68624       };
68625     } catch (std::exception& e) {
68626       {
68627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68628       };
68629     } catch (...) {
68630       {
68631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68632       };
68633     }
68634   }
68635   jresult = result;
68636   return jresult;
68637 }
68638
68639
68640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
68641   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68642
68643   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68644   {
68645     try {
68646       (arg1)->Refresh();
68647     } catch (std::out_of_range& e) {
68648       {
68649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68650       };
68651     } catch (std::exception& e) {
68652       {
68653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68654       };
68655     } catch (...) {
68656       {
68657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68658       };
68659     }
68660   }
68661 }
68662
68663
68664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
68665   void * jresult ;
68666   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68667   Dali::Toolkit::ItemId arg2 ;
68668   Dali::Actor result;
68669
68670   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68671   arg2 = (Dali::Toolkit::ItemId)jarg2;
68672   {
68673     try {
68674       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
68675     } catch (std::out_of_range& e) {
68676       {
68677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68678       };
68679     } catch (std::exception& e) {
68680       {
68681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68682       };
68683     } catch (...) {
68684       {
68685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68686       };
68687     }
68688   }
68689   jresult = new Dali::Actor((const Dali::Actor &)result);
68690   return jresult;
68691 }
68692
68693
68694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
68695   unsigned int jresult ;
68696   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68697   Dali::Actor arg2 ;
68698   Dali::Actor *argp2 ;
68699   Dali::Toolkit::ItemId result;
68700
68701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68702   argp2 = (Dali::Actor *)jarg2;
68703   if (!argp2) {
68704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68705     return 0;
68706   }
68707   arg2 = *argp2;
68708   {
68709     try {
68710       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
68711     } catch (std::out_of_range& e) {
68712       {
68713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68714       };
68715     } catch (std::exception& e) {
68716       {
68717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68718       };
68719     } catch (...) {
68720       {
68721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68722       };
68723     }
68724   }
68725   jresult = result;
68726   return jresult;
68727 }
68728
68729
68730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
68731   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68732   Dali::Toolkit::Item arg2 ;
68733   float arg3 ;
68734   Dali::Toolkit::Item *argp2 ;
68735
68736   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68737   argp2 = (Dali::Toolkit::Item *)jarg2;
68738   if (!argp2) {
68739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68740     return ;
68741   }
68742   arg2 = *argp2;
68743   arg3 = (float)jarg3;
68744   {
68745     try {
68746       (arg1)->InsertItem(arg2,arg3);
68747     } catch (std::out_of_range& e) {
68748       {
68749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68750       };
68751     } catch (std::exception& e) {
68752       {
68753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68754       };
68755     } catch (...) {
68756       {
68757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68758       };
68759     }
68760   }
68761 }
68762
68763
68764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
68765   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68766   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68767   float arg3 ;
68768
68769   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68770   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68771   if (!arg2) {
68772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68773     return ;
68774   }
68775   arg3 = (float)jarg3;
68776   {
68777     try {
68778       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68779     } catch (std::out_of_range& e) {
68780       {
68781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68782       };
68783     } catch (std::exception& e) {
68784       {
68785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68786       };
68787     } catch (...) {
68788       {
68789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68790       };
68791     }
68792   }
68793 }
68794
68795
68796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
68797   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68798   Dali::Toolkit::ItemId arg2 ;
68799   float arg3 ;
68800
68801   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68802   arg2 = (Dali::Toolkit::ItemId)jarg2;
68803   arg3 = (float)jarg3;
68804   {
68805     try {
68806       (arg1)->RemoveItem(arg2,arg3);
68807     } catch (std::out_of_range& e) {
68808       {
68809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68810       };
68811     } catch (std::exception& e) {
68812       {
68813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68814       };
68815     } catch (...) {
68816       {
68817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68818       };
68819     }
68820   }
68821 }
68822
68823
68824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
68825   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68826   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
68827   float arg3 ;
68828
68829   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68830   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
68831   if (!arg2) {
68832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
68833     return ;
68834   }
68835   arg3 = (float)jarg3;
68836   {
68837     try {
68838       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
68839     } catch (std::out_of_range& e) {
68840       {
68841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68842       };
68843     } catch (std::exception& e) {
68844       {
68845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68846       };
68847     } catch (...) {
68848       {
68849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68850       };
68851     }
68852   }
68853 }
68854
68855
68856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
68857   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68858   Dali::Toolkit::Item arg2 ;
68859   float arg3 ;
68860   Dali::Toolkit::Item *argp2 ;
68861
68862   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68863   argp2 = (Dali::Toolkit::Item *)jarg2;
68864   if (!argp2) {
68865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
68866     return ;
68867   }
68868   arg2 = *argp2;
68869   arg3 = (float)jarg3;
68870   {
68871     try {
68872       (arg1)->ReplaceItem(arg2,arg3);
68873     } catch (std::out_of_range& e) {
68874       {
68875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68876       };
68877     } catch (std::exception& e) {
68878       {
68879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68880       };
68881     } catch (...) {
68882       {
68883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68884       };
68885     }
68886   }
68887 }
68888
68889
68890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
68891   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68892   Dali::Toolkit::ItemContainer *arg2 = 0 ;
68893   float arg3 ;
68894
68895   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68896   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
68897   if (!arg2) {
68898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
68899     return ;
68900   }
68901   arg3 = (float)jarg3;
68902   {
68903     try {
68904       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
68905     } catch (std::out_of_range& e) {
68906       {
68907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68908       };
68909     } catch (std::exception& e) {
68910       {
68911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68912       };
68913     } catch (...) {
68914       {
68915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68916       };
68917     }
68918   }
68919 }
68920
68921
68922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
68923   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68924   Dali::Vector3 *arg2 = 0 ;
68925
68926   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68927   arg2 = (Dali::Vector3 *)jarg2;
68928   if (!arg2) {
68929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68930     return ;
68931   }
68932   {
68933     try {
68934       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
68935     } catch (std::out_of_range& e) {
68936       {
68937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68938       };
68939     } catch (std::exception& e) {
68940       {
68941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68942       };
68943     } catch (...) {
68944       {
68945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68946       };
68947     }
68948   }
68949 }
68950
68951
68952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
68953   void * jresult ;
68954   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68955   Dali::Vector3 result;
68956
68957   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68958   {
68959     try {
68960       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
68961     } catch (std::out_of_range& e) {
68962       {
68963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68964       };
68965     } catch (std::exception& e) {
68966       {
68967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68968       };
68969     } catch (...) {
68970       {
68971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68972       };
68973     }
68974   }
68975   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
68981   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
68982   Dali::Vector3 *arg2 = 0 ;
68983
68984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
68985   arg2 = (Dali::Vector3 *)jarg2;
68986   if (!arg2) {
68987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68988     return ;
68989   }
68990   {
68991     try {
68992       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
68993     } catch (std::out_of_range& e) {
68994       {
68995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68996       };
68997     } catch (std::exception& e) {
68998       {
68999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69000       };
69001     } catch (...) {
69002       {
69003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69004       };
69005     }
69006   }
69007 }
69008
69009
69010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
69011   void * jresult ;
69012   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69013   Dali::Vector3 result;
69014
69015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69016   {
69017     try {
69018       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
69019     } catch (std::out_of_range& e) {
69020       {
69021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69022       };
69023     } catch (std::exception& e) {
69024       {
69025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69026       };
69027     } catch (...) {
69028       {
69029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69030       };
69031     }
69032   }
69033   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69034   return jresult;
69035 }
69036
69037
69038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
69039   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69040   Dali::Toolkit::ItemRange *arg2 = 0 ;
69041
69042   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69043   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69044   if (!arg2) {
69045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
69046     return ;
69047   }
69048   {
69049     try {
69050       (arg1)->GetItemsRange(*arg2);
69051     } catch (std::out_of_range& e) {
69052       {
69053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69054       };
69055     } catch (std::exception& e) {
69056       {
69057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69058       };
69059     } catch (...) {
69060       {
69061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69062       };
69063     }
69064   }
69065 }
69066
69067
69068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
69069   void * jresult ;
69070   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69071   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
69072
69073   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69074   {
69075     try {
69076       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
69077     } catch (std::out_of_range& e) {
69078       {
69079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69080       };
69081     } catch (std::exception& e) {
69082       {
69083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69084       };
69085     } catch (...) {
69086       {
69087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69088       };
69089     }
69090   }
69091   jresult = (void *)result;
69092   return jresult;
69093 }
69094
69095
69096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
69097   Dali::Vector3 *arg1 = 0 ;
69098   PropertyInputContainer *arg2 = 0 ;
69099
69100   arg1 = (Dali::Vector3 *)jarg1;
69101   if (!arg1) {
69102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69103     return ;
69104   }
69105   arg2 = (PropertyInputContainer *)jarg2;
69106   if (!arg2) {
69107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
69108     return ;
69109   }
69110   {
69111     try {
69112       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
69113     } catch (std::out_of_range& e) {
69114       {
69115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69116       };
69117     } catch (std::exception& e) {
69118       {
69119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69120       };
69121     } catch (...) {
69122       {
69123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69124       };
69125     }
69126   }
69127 }
69128
69129
69130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
69131   Dali::Vector3 *arg1 = 0 ;
69132   PropertyInputContainer *arg2 = 0 ;
69133
69134   arg1 = (Dali::Vector3 *)jarg1;
69135   if (!arg1) {
69136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69137     return ;
69138   }
69139   arg2 = (PropertyInputContainer *)jarg2;
69140   if (!arg2) {
69141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
69142     return ;
69143   }
69144   {
69145     try {
69146       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
69147     } catch (std::out_of_range& e) {
69148       {
69149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69150       };
69151     } catch (std::exception& e) {
69152       {
69153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69158       };
69159     }
69160   }
69161 }
69162
69163
69164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
69165   void * jresult ;
69166   Dali::Toolkit::ScrollViewEffect *result = 0 ;
69167
69168   {
69169     try {
69170       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
69171     } catch (std::out_of_range& e) {
69172       {
69173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69174       };
69175     } catch (std::exception& e) {
69176       {
69177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (...) {
69180       {
69181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69182       };
69183     }
69184   }
69185   jresult = (void *)result;
69186   return jresult;
69187 }
69188
69189
69190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
69191   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
69192
69193   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
69194   {
69195     try {
69196       delete arg1;
69197     } catch (std::out_of_range& e) {
69198       {
69199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69200       };
69201     } catch (std::exception& e) {
69202       {
69203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69204       };
69205     } catch (...) {
69206       {
69207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69208       };
69209     }
69210   }
69211 }
69212
69213
69214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
69215   void * jresult ;
69216   Dali::Path arg1 ;
69217   Dali::Vector3 *arg2 = 0 ;
69218   Dali::Property::Index arg3 ;
69219   Dali::Vector3 *arg4 = 0 ;
69220   unsigned int arg5 ;
69221   Dali::Path *argp1 ;
69222   Dali::Toolkit::ScrollViewPagePathEffect result;
69223
69224   argp1 = (Dali::Path *)jarg1;
69225   if (!argp1) {
69226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
69227     return 0;
69228   }
69229   arg1 = *argp1;
69230   arg2 = (Dali::Vector3 *)jarg2;
69231   if (!arg2) {
69232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69233     return 0;
69234   }
69235   arg3 = (Dali::Property::Index)jarg3;
69236   arg4 = (Dali::Vector3 *)jarg4;
69237   if (!arg4) {
69238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69239     return 0;
69240   }
69241   arg5 = (unsigned int)jarg5;
69242   {
69243     try {
69244       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69256       };
69257     }
69258   }
69259   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
69265   void * jresult ;
69266   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
69267
69268   {
69269     try {
69270       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
69271     } catch (std::out_of_range& e) {
69272       {
69273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (std::exception& e) {
69276       {
69277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69278       };
69279     } catch (...) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69282       };
69283     }
69284   }
69285   jresult = (void *)result;
69286   return jresult;
69287 }
69288
69289
69290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
69291   void * jresult ;
69292   Dali::BaseHandle arg1 ;
69293   Dali::BaseHandle *argp1 ;
69294   Dali::Toolkit::ScrollViewPagePathEffect result;
69295
69296   argp1 = (Dali::BaseHandle *)jarg1;
69297   if (!argp1) {
69298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69299     return 0;
69300   }
69301   arg1 = *argp1;
69302   {
69303     try {
69304       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
69305     } catch (std::out_of_range& e) {
69306       {
69307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69308       };
69309     } catch (std::exception& e) {
69310       {
69311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69312       };
69313     } catch (...) {
69314       {
69315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69316       };
69317     }
69318   }
69319   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
69325   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69326   Dali::Actor arg2 ;
69327   unsigned int arg3 ;
69328   Dali::Actor *argp2 ;
69329
69330   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69331   argp2 = (Dali::Actor *)jarg2;
69332   if (!argp2) {
69333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69334     return ;
69335   }
69336   arg2 = *argp2;
69337   arg3 = (unsigned int)jarg3;
69338   {
69339     try {
69340       (arg1)->ApplyToPage(arg2,arg3);
69341     } catch (std::out_of_range& e) {
69342       {
69343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69344       };
69345     } catch (std::exception& e) {
69346       {
69347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69348       };
69349     } catch (...) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69352       };
69353     }
69354   }
69355 }
69356
69357
69358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
69359   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
69360
69361   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
69362   {
69363     try {
69364       delete arg1;
69365     } catch (std::out_of_range& e) {
69366       {
69367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69368       };
69369     } catch (std::exception& e) {
69370       {
69371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69372       };
69373     } catch (...) {
69374       {
69375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69376       };
69377     }
69378   }
69379 }
69380
69381
69382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
69383   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69384   Dali::Toolkit::ClampState arg2 ;
69385
69386   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69387   arg2 = (Dali::Toolkit::ClampState)jarg2;
69388   if (arg1) (arg1)->x = arg2;
69389 }
69390
69391
69392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
69393   int jresult ;
69394   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69395   Dali::Toolkit::ClampState result;
69396
69397   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69398   result = (Dali::Toolkit::ClampState) ((arg1)->x);
69399   jresult = (int)result;
69400   return jresult;
69401 }
69402
69403
69404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
69405   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69406   Dali::Toolkit::ClampState arg2 ;
69407
69408   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69409   arg2 = (Dali::Toolkit::ClampState)jarg2;
69410   if (arg1) (arg1)->y = arg2;
69411 }
69412
69413
69414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
69415   int jresult ;
69416   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69417   Dali::Toolkit::ClampState result;
69418
69419   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69420   result = (Dali::Toolkit::ClampState) ((arg1)->y);
69421   jresult = (int)result;
69422   return jresult;
69423 }
69424
69425
69426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
69427   void * jresult ;
69428   Dali::Toolkit::ClampState2D *result = 0 ;
69429
69430   {
69431     try {
69432       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
69433     } catch (std::out_of_range& e) {
69434       {
69435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (std::exception& e) {
69438       {
69439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (...) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69444       };
69445     }
69446   }
69447   jresult = (void *)result;
69448   return jresult;
69449 }
69450
69451
69452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
69453   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
69454
69455   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
69456   {
69457     try {
69458       delete arg1;
69459     } catch (std::out_of_range& e) {
69460       {
69461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69462       };
69463     } catch (std::exception& e) {
69464       {
69465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69466       };
69467     } catch (...) {
69468       {
69469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69470       };
69471     }
69472   }
69473 }
69474
69475
69476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
69477   void * jresult ;
69478   float arg1 ;
69479   float arg2 ;
69480   bool arg3 ;
69481   Dali::Toolkit::RulerDomain *result = 0 ;
69482
69483   arg1 = (float)jarg1;
69484   arg2 = (float)jarg2;
69485   arg3 = jarg3 ? true : false;
69486   {
69487     try {
69488       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
69489     } catch (std::out_of_range& e) {
69490       {
69491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (std::exception& e) {
69494       {
69495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (...) {
69498       {
69499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69500       };
69501     }
69502   }
69503   jresult = (void *)result;
69504   return jresult;
69505 }
69506
69507
69508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
69509   void * jresult ;
69510   float arg1 ;
69511   float arg2 ;
69512   Dali::Toolkit::RulerDomain *result = 0 ;
69513
69514   arg1 = (float)jarg1;
69515   arg2 = (float)jarg2;
69516   {
69517     try {
69518       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
69519     } catch (std::out_of_range& e) {
69520       {
69521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69522       };
69523     } catch (std::exception& e) {
69524       {
69525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69526       };
69527     } catch (...) {
69528       {
69529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69530       };
69531     }
69532   }
69533   jresult = (void *)result;
69534   return jresult;
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
69539   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69540   float arg2 ;
69541
69542   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69543   arg2 = (float)jarg2;
69544   if (arg1) (arg1)->min = arg2;
69545 }
69546
69547
69548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
69549   float jresult ;
69550   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69551   float result;
69552
69553   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69554   result = (float) ((arg1)->min);
69555   jresult = result;
69556   return jresult;
69557 }
69558
69559
69560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
69561   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69562   float arg2 ;
69563
69564   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69565   arg2 = (float)jarg2;
69566   if (arg1) (arg1)->max = arg2;
69567 }
69568
69569
69570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
69571   float jresult ;
69572   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69573   float result;
69574
69575   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69576   result = (float) ((arg1)->max);
69577   jresult = result;
69578   return jresult;
69579 }
69580
69581
69582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
69583   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69584   bool arg2 ;
69585
69586   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69587   arg2 = jarg2 ? true : false;
69588   if (arg1) (arg1)->enabled = arg2;
69589 }
69590
69591
69592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
69593   unsigned int jresult ;
69594   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69595   bool result;
69596
69597   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69598   result = (bool) ((arg1)->enabled);
69599   jresult = result;
69600   return jresult;
69601 }
69602
69603
69604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
69605   float jresult ;
69606   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69607   float arg2 ;
69608   float arg3 ;
69609   float arg4 ;
69610   float result;
69611
69612   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69613   arg2 = (float)jarg2;
69614   arg3 = (float)jarg3;
69615   arg4 = (float)jarg4;
69616   {
69617     try {
69618       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
69619     } catch (std::out_of_range& e) {
69620       {
69621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69622       };
69623     } catch (std::exception& e) {
69624       {
69625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69626       };
69627     } catch (...) {
69628       {
69629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69630       };
69631     }
69632   }
69633   jresult = result;
69634   return jresult;
69635 }
69636
69637
69638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
69639   float jresult ;
69640   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69641   float arg2 ;
69642   float arg3 ;
69643   float result;
69644
69645   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69646   arg2 = (float)jarg2;
69647   arg3 = (float)jarg3;
69648   {
69649     try {
69650       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
69651     } catch (std::out_of_range& e) {
69652       {
69653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69654       };
69655     } catch (std::exception& e) {
69656       {
69657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69658       };
69659     } catch (...) {
69660       {
69661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69662       };
69663     }
69664   }
69665   jresult = result;
69666   return jresult;
69667 }
69668
69669
69670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
69671   float jresult ;
69672   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69673   float arg2 ;
69674   float result;
69675
69676   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69677   arg2 = (float)jarg2;
69678   {
69679     try {
69680       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
69681     } catch (std::out_of_range& e) {
69682       {
69683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69684       };
69685     } catch (std::exception& e) {
69686       {
69687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69688       };
69689     } catch (...) {
69690       {
69691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69692       };
69693     }
69694   }
69695   jresult = result;
69696   return jresult;
69697 }
69698
69699
69700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
69701   float jresult ;
69702   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69703   float arg2 ;
69704   float arg3 ;
69705   float arg4 ;
69706   Dali::Toolkit::ClampState *arg5 = 0 ;
69707   float result;
69708
69709   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69710   arg2 = (float)jarg2;
69711   arg3 = (float)jarg3;
69712   arg4 = (float)jarg4;
69713   arg5 = (Dali::Toolkit::ClampState *)jarg5;
69714   if (!arg5) {
69715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
69716     return 0;
69717   }
69718   {
69719     try {
69720       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
69721     } catch (std::out_of_range& e) {
69722       {
69723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69724       };
69725     } catch (std::exception& e) {
69726       {
69727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69728       };
69729     } catch (...) {
69730       {
69731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69732       };
69733     }
69734   }
69735   jresult = result;
69736   return jresult;
69737 }
69738
69739
69740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
69741   float jresult ;
69742   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69743   float result;
69744
69745   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69746   {
69747     try {
69748       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69756       };
69757     } catch (...) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69760       };
69761     }
69762   }
69763   jresult = result;
69764   return jresult;
69765 }
69766
69767
69768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
69769   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
69770
69771   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
69772   {
69773     try {
69774       delete arg1;
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69786       };
69787     }
69788   }
69789 }
69790
69791
69792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
69793   float jresult ;
69794   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69795   float arg2 ;
69796   float arg3 ;
69797   float result;
69798
69799   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69800   arg2 = (float)jarg2;
69801   arg3 = (float)jarg3;
69802   {
69803     try {
69804       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
69805     } catch (std::out_of_range& e) {
69806       {
69807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69808       };
69809     } catch (std::exception& e) {
69810       {
69811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69816       };
69817     }
69818   }
69819   jresult = result;
69820   return jresult;
69821 }
69822
69823
69824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
69825   float jresult ;
69826   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69827   float arg2 ;
69828   float result;
69829
69830   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69831   arg2 = (float)jarg2;
69832   {
69833     try {
69834       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69842       };
69843     } catch (...) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69846       };
69847     }
69848   }
69849   jresult = result;
69850   return jresult;
69851 }
69852
69853
69854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
69855   float jresult ;
69856   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69857   unsigned int arg2 ;
69858   unsigned int *arg3 = 0 ;
69859   bool arg4 ;
69860   float result;
69861
69862   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69863   arg2 = (unsigned int)jarg2;
69864   arg3 = (unsigned int *)jarg3;
69865   arg4 = jarg4 ? true : false;
69866   {
69867     try {
69868       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
69869     } catch (std::out_of_range& e) {
69870       {
69871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69872       };
69873     } catch (std::exception& e) {
69874       {
69875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69876       };
69877     } catch (...) {
69878       {
69879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69880       };
69881     }
69882   }
69883   jresult = result;
69884   return jresult;
69885 }
69886
69887
69888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
69889   unsigned int jresult ;
69890   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69891   float arg2 ;
69892   bool arg3 ;
69893   unsigned int result;
69894
69895   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69896   arg2 = (float)jarg2;
69897   arg3 = jarg3 ? true : false;
69898   {
69899     try {
69900       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (...) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69912       };
69913     }
69914   }
69915   jresult = result;
69916   return jresult;
69917 }
69918
69919
69920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
69921   unsigned int jresult ;
69922   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69923   unsigned int result;
69924
69925   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69926   {
69927     try {
69928       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
69929     } catch (std::out_of_range& e) {
69930       {
69931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69932       };
69933     } catch (std::exception& e) {
69934       {
69935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69936       };
69937     } catch (...) {
69938       {
69939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69940       };
69941     }
69942   }
69943   jresult = result;
69944   return jresult;
69945 }
69946
69947
69948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
69949   int jresult ;
69950   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69951   Dali::Toolkit::Ruler::RulerType result;
69952
69953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69954   {
69955     try {
69956       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
69957     } catch (std::out_of_range& e) {
69958       {
69959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69960       };
69961     } catch (std::exception& e) {
69962       {
69963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69964       };
69965     } catch (...) {
69966       {
69967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69968       };
69969     }
69970   }
69971   jresult = (int)result;
69972   return jresult;
69973 }
69974
69975
69976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
69977   unsigned int jresult ;
69978   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
69979   bool result;
69980
69981   arg1 = (Dali::Toolkit::Ruler *)jarg1;
69982   {
69983     try {
69984       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
69985     } catch (std::out_of_range& e) {
69986       {
69987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69988       };
69989     } catch (std::exception& e) {
69990       {
69991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69992       };
69993     } catch (...) {
69994       {
69995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69996       };
69997     }
69998   }
69999   jresult = result;
70000   return jresult;
70001 }
70002
70003
70004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
70005   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70006
70007   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70008   {
70009     try {
70010       (arg1)->Enable();
70011     } catch (std::out_of_range& e) {
70012       {
70013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70014       };
70015     } catch (std::exception& e) {
70016       {
70017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70018       };
70019     } catch (...) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70022       };
70023     }
70024   }
70025 }
70026
70027
70028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
70029   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70030
70031   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70032   {
70033     try {
70034       (arg1)->Disable();
70035     } catch (std::out_of_range& e) {
70036       {
70037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70038       };
70039     } catch (std::exception& e) {
70040       {
70041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70042       };
70043     } catch (...) {
70044       {
70045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70046       };
70047     }
70048   }
70049 }
70050
70051
70052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
70053   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70054   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
70055   Dali::Toolkit::RulerDomain *argp2 ;
70056
70057   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70058   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
70059   if (!argp2) {
70060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
70061     return ;
70062   }
70063   arg2 = *argp2;
70064   {
70065     try {
70066       (arg1)->SetDomain(arg2);
70067     } catch (std::out_of_range& e) {
70068       {
70069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70070       };
70071     } catch (std::exception& e) {
70072       {
70073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70074       };
70075     } catch (...) {
70076       {
70077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70078       };
70079     }
70080   }
70081 }
70082
70083
70084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
70085   void * jresult ;
70086   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70087   Dali::Toolkit::RulerDomain *result = 0 ;
70088
70089   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70090   {
70091     try {
70092       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
70093     } catch (std::out_of_range& e) {
70094       {
70095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70096       };
70097     } catch (std::exception& e) {
70098       {
70099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70100       };
70101     } catch (...) {
70102       {
70103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70104       };
70105     }
70106   }
70107   jresult = (void *)result;
70108   return jresult;
70109 }
70110
70111
70112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
70113   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70114
70115   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70116   {
70117     try {
70118       (arg1)->DisableDomain();
70119     } catch (std::out_of_range& e) {
70120       {
70121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70122       };
70123     } catch (std::exception& e) {
70124       {
70125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70126       };
70127     } catch (...) {
70128       {
70129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70130       };
70131     }
70132   }
70133 }
70134
70135
70136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
70137   float jresult ;
70138   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70139   float arg2 ;
70140   float arg3 ;
70141   float arg4 ;
70142   float result;
70143
70144   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70145   arg2 = (float)jarg2;
70146   arg3 = (float)jarg3;
70147   arg4 = (float)jarg4;
70148   {
70149     try {
70150       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
70151     } catch (std::out_of_range& e) {
70152       {
70153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70154       };
70155     } catch (std::exception& e) {
70156       {
70157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70158       };
70159     } catch (...) {
70160       {
70161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70162       };
70163     }
70164   }
70165   jresult = result;
70166   return jresult;
70167 }
70168
70169
70170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
70171   float jresult ;
70172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70173   float arg2 ;
70174   float arg3 ;
70175   float result;
70176
70177   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70178   arg2 = (float)jarg2;
70179   arg3 = (float)jarg3;
70180   {
70181     try {
70182       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
70183     } catch (std::out_of_range& e) {
70184       {
70185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70186       };
70187     } catch (std::exception& e) {
70188       {
70189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (...) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70194       };
70195     }
70196   }
70197   jresult = result;
70198   return jresult;
70199 }
70200
70201
70202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
70203   float jresult ;
70204   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70205   float arg2 ;
70206   float result;
70207
70208   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70209   arg2 = (float)jarg2;
70210   {
70211     try {
70212       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70220       };
70221     } catch (...) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70224       };
70225     }
70226   }
70227   jresult = result;
70228   return jresult;
70229 }
70230
70231
70232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
70233   float jresult ;
70234   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70235   float arg2 ;
70236   float arg3 ;
70237   float arg4 ;
70238   Dali::Toolkit::ClampState *arg5 = 0 ;
70239   float result;
70240
70241   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70242   arg2 = (float)jarg2;
70243   arg3 = (float)jarg3;
70244   arg4 = (float)jarg4;
70245   arg5 = (Dali::Toolkit::ClampState *)jarg5;
70246   if (!arg5) {
70247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70248     return 0;
70249   }
70250   {
70251     try {
70252       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70264       };
70265     }
70266   }
70267   jresult = result;
70268   return jresult;
70269 }
70270
70271
70272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
70273   float jresult ;
70274   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70275   float arg2 ;
70276   float arg3 ;
70277   float arg4 ;
70278   float arg5 ;
70279   float result;
70280
70281   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70282   arg2 = (float)jarg2;
70283   arg3 = (float)jarg3;
70284   arg4 = (float)jarg4;
70285   arg5 = (float)jarg5;
70286   {
70287     try {
70288       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
70289     } catch (std::out_of_range& e) {
70290       {
70291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70292       };
70293     } catch (std::exception& e) {
70294       {
70295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70296       };
70297     } catch (...) {
70298       {
70299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70300       };
70301     }
70302   }
70303   jresult = result;
70304   return jresult;
70305 }
70306
70307
70308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
70309   float jresult ;
70310   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70311   float arg2 ;
70312   float arg3 ;
70313   float arg4 ;
70314   float result;
70315
70316   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70317   arg2 = (float)jarg2;
70318   arg3 = (float)jarg3;
70319   arg4 = (float)jarg4;
70320   {
70321     try {
70322       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
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 float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
70343   float jresult ;
70344   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70345   float arg2 ;
70346   float arg3 ;
70347   float result;
70348
70349   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70350   arg2 = (float)jarg2;
70351   arg3 = (float)jarg3;
70352   {
70353     try {
70354       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
70355     } catch (std::out_of_range& e) {
70356       {
70357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70358       };
70359     } catch (std::exception& e) {
70360       {
70361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70362       };
70363     } catch (...) {
70364       {
70365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70366       };
70367     }
70368   }
70369   jresult = result;
70370   return jresult;
70371 }
70372
70373
70374 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
70375   float jresult ;
70376   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70377   float arg2 ;
70378   float result;
70379
70380   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70381   arg2 = (float)jarg2;
70382   {
70383     try {
70384       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
70385     } catch (std::out_of_range& e) {
70386       {
70387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70388       };
70389     } catch (std::exception& e) {
70390       {
70391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70392       };
70393     } catch (...) {
70394       {
70395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70396       };
70397     }
70398   }
70399   jresult = result;
70400   return jresult;
70401 }
70402
70403
70404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
70405   float jresult ;
70406   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
70407   float arg2 ;
70408   float arg3 ;
70409   float arg4 ;
70410   float arg5 ;
70411   Dali::Toolkit::ClampState *arg6 = 0 ;
70412   float result;
70413
70414   arg1 = (Dali::Toolkit::Ruler *)jarg1;
70415   arg2 = (float)jarg2;
70416   arg3 = (float)jarg3;
70417   arg4 = (float)jarg4;
70418   arg5 = (float)jarg5;
70419   arg6 = (Dali::Toolkit::ClampState *)jarg6;
70420   if (!arg6) {
70421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
70422     return 0;
70423   }
70424   {
70425     try {
70426       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
70427     } catch (std::out_of_range& e) {
70428       {
70429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70430       };
70431     } catch (std::exception& e) {
70432       {
70433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70434       };
70435     } catch (...) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70438       };
70439     }
70440   }
70441   jresult = result;
70442   return jresult;
70443 }
70444
70445
70446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
70447   void * jresult ;
70448   Dali::Toolkit::DefaultRuler *result = 0 ;
70449
70450   {
70451     try {
70452       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
70453     } catch (std::out_of_range& e) {
70454       {
70455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70456       };
70457     } catch (std::exception& e) {
70458       {
70459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70460       };
70461     } catch (...) {
70462       {
70463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70464       };
70465     }
70466   }
70467   jresult = (void *)result;
70468   return jresult;
70469 }
70470
70471
70472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70473   float jresult ;
70474   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70475   float arg2 ;
70476   float arg3 ;
70477   float result;
70478
70479   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70480   arg2 = (float)jarg2;
70481   arg3 = (float)jarg3;
70482   {
70483     try {
70484       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
70485     } catch (std::out_of_range& e) {
70486       {
70487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70488       };
70489     } catch (std::exception& e) {
70490       {
70491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70492       };
70493     } catch (...) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70496       };
70497     }
70498   }
70499   jresult = result;
70500   return jresult;
70501 }
70502
70503
70504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70505   float jresult ;
70506   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70507   unsigned int arg2 ;
70508   unsigned int *arg3 = 0 ;
70509   bool arg4 ;
70510   float result;
70511
70512   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70513   arg2 = (unsigned int)jarg2;
70514   arg3 = (unsigned int *)jarg3;
70515   arg4 = jarg4 ? true : false;
70516   {
70517     try {
70518       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70519     } catch (std::out_of_range& e) {
70520       {
70521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70522       };
70523     } catch (std::exception& e) {
70524       {
70525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70530       };
70531     }
70532   }
70533   jresult = result;
70534   return jresult;
70535 }
70536
70537
70538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70539   unsigned int jresult ;
70540   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70541   float arg2 ;
70542   bool arg3 ;
70543   unsigned int result;
70544
70545   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70546   arg2 = (float)jarg2;
70547   arg3 = jarg3 ? true : false;
70548   {
70549     try {
70550       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70551     } catch (std::out_of_range& e) {
70552       {
70553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70554       };
70555     } catch (std::exception& e) {
70556       {
70557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70558       };
70559     } catch (...) {
70560       {
70561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70562       };
70563     }
70564   }
70565   jresult = result;
70566   return jresult;
70567 }
70568
70569
70570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
70571   unsigned int jresult ;
70572   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70573   unsigned int result;
70574
70575   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70576   {
70577     try {
70578       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
70579     } catch (std::out_of_range& e) {
70580       {
70581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70582       };
70583     } catch (std::exception& e) {
70584       {
70585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70586       };
70587     } catch (...) {
70588       {
70589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70590       };
70591     }
70592   }
70593   jresult = result;
70594   return jresult;
70595 }
70596
70597
70598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
70599   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
70600
70601   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
70602   {
70603     try {
70604       delete arg1;
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_new_FixedRuler__SWIG_0(float jarg1) {
70623   void * jresult ;
70624   float arg1 ;
70625   Dali::Toolkit::FixedRuler *result = 0 ;
70626
70627   arg1 = (float)jarg1;
70628   {
70629     try {
70630       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
70631     } catch (std::out_of_range& e) {
70632       {
70633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70634       };
70635     } catch (std::exception& e) {
70636       {
70637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70638       };
70639     } catch (...) {
70640       {
70641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70642       };
70643     }
70644   }
70645   jresult = (void *)result;
70646   return jresult;
70647 }
70648
70649
70650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
70651   void * jresult ;
70652   Dali::Toolkit::FixedRuler *result = 0 ;
70653
70654   {
70655     try {
70656       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
70657     } catch (std::out_of_range& e) {
70658       {
70659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70660       };
70661     } catch (std::exception& e) {
70662       {
70663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70664       };
70665     } catch (...) {
70666       {
70667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70668       };
70669     }
70670   }
70671   jresult = (void *)result;
70672   return jresult;
70673 }
70674
70675
70676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
70677   float jresult ;
70678   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70679   float arg2 ;
70680   float arg3 ;
70681   float result;
70682
70683   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70684   arg2 = (float)jarg2;
70685   arg3 = (float)jarg3;
70686   {
70687     try {
70688       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
70689     } catch (std::out_of_range& e) {
70690       {
70691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70692       };
70693     } catch (std::exception& e) {
70694       {
70695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70696       };
70697     } catch (...) {
70698       {
70699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70700       };
70701     }
70702   }
70703   jresult = result;
70704   return jresult;
70705 }
70706
70707
70708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
70709   float jresult ;
70710   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70711   unsigned int arg2 ;
70712   unsigned int *arg3 = 0 ;
70713   bool arg4 ;
70714   float result;
70715
70716   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70717   arg2 = (unsigned int)jarg2;
70718   arg3 = (unsigned int *)jarg3;
70719   arg4 = jarg4 ? true : false;
70720   {
70721     try {
70722       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
70723     } catch (std::out_of_range& e) {
70724       {
70725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70726       };
70727     } catch (std::exception& e) {
70728       {
70729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70730       };
70731     } catch (...) {
70732       {
70733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70734       };
70735     }
70736   }
70737   jresult = result;
70738   return jresult;
70739 }
70740
70741
70742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
70743   unsigned int jresult ;
70744   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70745   float arg2 ;
70746   bool arg3 ;
70747   unsigned int result;
70748
70749   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70750   arg2 = (float)jarg2;
70751   arg3 = jarg3 ? true : false;
70752   {
70753     try {
70754       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
70755     } catch (std::out_of_range& e) {
70756       {
70757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70758       };
70759     } catch (std::exception& e) {
70760       {
70761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70762       };
70763     } catch (...) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70766       };
70767     }
70768   }
70769   jresult = result;
70770   return jresult;
70771 }
70772
70773
70774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
70775   unsigned int jresult ;
70776   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70777   unsigned int result;
70778
70779   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70780   {
70781     try {
70782       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
70783     } catch (std::out_of_range& e) {
70784       {
70785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70786       };
70787     } catch (std::exception& e) {
70788       {
70789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70790       };
70791     } catch (...) {
70792       {
70793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70794       };
70795     }
70796   }
70797   jresult = result;
70798   return jresult;
70799 }
70800
70801
70802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
70803   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
70804
70805   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
70806   {
70807     try {
70808       delete arg1;
70809     } catch (std::out_of_range& e) {
70810       {
70811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70812       };
70813     } catch (std::exception& e) {
70814       {
70815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70816       };
70817     } catch (...) {
70818       {
70819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70820       };
70821     }
70822   }
70823 }
70824
70825
70826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
70827   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70828   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70829
70830   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70831   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70832   if (arg1) (arg1)->scale = *arg2;
70833 }
70834
70835
70836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
70837   void * jresult ;
70838   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70839   Dali::Toolkit::ClampState2D *result = 0 ;
70840
70841   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70842   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
70843   jresult = (void *)result;
70844   return jresult;
70845 }
70846
70847
70848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
70849   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70850   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
70851
70852   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70853   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
70854   if (arg1) (arg1)->position = *arg2;
70855 }
70856
70857
70858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
70859   void * jresult ;
70860   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70861   Dali::Toolkit::ClampState2D *result = 0 ;
70862
70863   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70864   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
70865   jresult = (void *)result;
70866   return jresult;
70867 }
70868
70869
70870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
70871   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70872   Dali::Toolkit::ClampState arg2 ;
70873
70874   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70875   arg2 = (Dali::Toolkit::ClampState)jarg2;
70876   if (arg1) (arg1)->rotation = arg2;
70877 }
70878
70879
70880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
70881   int jresult ;
70882   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70883   Dali::Toolkit::ClampState result;
70884
70885   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70886   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
70887   jresult = (int)result;
70888   return jresult;
70889 }
70890
70891
70892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
70893   void * jresult ;
70894   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
70895
70896   {
70897     try {
70898       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
70899     } catch (std::out_of_range& e) {
70900       {
70901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70902       };
70903     } catch (std::exception& e) {
70904       {
70905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70906       };
70907     } catch (...) {
70908       {
70909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70910       };
70911     }
70912   }
70913   jresult = (void *)result;
70914   return jresult;
70915 }
70916
70917
70918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
70919   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
70920
70921   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
70922   {
70923     try {
70924       delete arg1;
70925     } catch (std::out_of_range& e) {
70926       {
70927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70928       };
70929     } catch (std::exception& e) {
70930       {
70931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70932       };
70933     } catch (...) {
70934       {
70935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70936       };
70937     }
70938   }
70939 }
70940
70941
70942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
70943   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70944   Dali::Toolkit::SnapType arg2 ;
70945
70946   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70947   arg2 = (Dali::Toolkit::SnapType)jarg2;
70948   if (arg1) (arg1)->type = arg2;
70949 }
70950
70951
70952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
70953   int jresult ;
70954   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70955   Dali::Toolkit::SnapType result;
70956
70957   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70958   result = (Dali::Toolkit::SnapType) ((arg1)->type);
70959   jresult = (int)result;
70960   return jresult;
70961 }
70962
70963
70964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
70965   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70966   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
70967
70968   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70969   arg2 = (Dali::Vector2 *)jarg2;
70970   if (arg1) (arg1)->position = *arg2;
70971 }
70972
70973
70974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
70975   void * jresult ;
70976   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70977   Dali::Vector2 *result = 0 ;
70978
70979   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70980   result = (Dali::Vector2 *)& ((arg1)->position);
70981   jresult = (void *)result;
70982   return jresult;
70983 }
70984
70985
70986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
70987   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70988   float arg2 ;
70989
70990   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
70991   arg2 = (float)jarg2;
70992   if (arg1) (arg1)->duration = arg2;
70993 }
70994
70995
70996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
70997   float jresult ;
70998   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
70999   float result;
71000
71001   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
71002   result = (float) ((arg1)->duration);
71003   jresult = result;
71004   return jresult;
71005 }
71006
71007
71008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
71009   void * jresult ;
71010   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
71011
71012   {
71013     try {
71014       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
71015     } catch (std::out_of_range& e) {
71016       {
71017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71018       };
71019     } catch (std::exception& e) {
71020       {
71021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71022       };
71023     } catch (...) {
71024       {
71025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71026       };
71027     }
71028   }
71029   jresult = (void *)result;
71030   return jresult;
71031 }
71032
71033
71034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
71035   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
71036
71037   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
71038   {
71039     try {
71040       delete arg1;
71041     } catch (std::out_of_range& e) {
71042       {
71043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71044       };
71045     } catch (std::exception& e) {
71046       {
71047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71048       };
71049     } catch (...) {
71050       {
71051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71052       };
71053     }
71054   }
71055 }
71056
71057
71058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
71059   int jresult ;
71060   int result;
71061
71062   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
71063   jresult = (int)result;
71064   return jresult;
71065 }
71066
71067
71068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
71069   int jresult ;
71070   int result;
71071
71072   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
71073   jresult = (int)result;
71074   return jresult;
71075 }
71076
71077
71078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
71079   int jresult ;
71080   int result;
71081
71082   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
71083   jresult = (int)result;
71084   return jresult;
71085 }
71086
71087
71088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
71089   int jresult ;
71090   int result;
71091
71092   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
71093   jresult = (int)result;
71094   return jresult;
71095 }
71096
71097
71098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
71099   int jresult ;
71100   int result;
71101
71102   result = (int)Dali::Toolkit::DevelScrollView::Property::SCROLL_MODE;
71103   jresult = (int)result;
71104   return jresult;
71105 }
71106
71107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
71108   int jresult ;
71109   int result;
71110
71111   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
71112   jresult = (int)result;
71113   return jresult;
71114 }
71115
71116
71117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
71118   int jresult ;
71119   int result;
71120
71121   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
71122   jresult = (int)result;
71123   return jresult;
71124 }
71125
71126
71127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
71128   int jresult ;
71129   int result;
71130
71131   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
71132   jresult = (int)result;
71133   return jresult;
71134 }
71135
71136
71137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
71138   int jresult ;
71139   int result;
71140
71141   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
71142   jresult = (int)result;
71143   return jresult;
71144 }
71145
71146
71147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
71148   int jresult ;
71149   int result;
71150
71151   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
71152   jresult = (int)result;
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
71158   int jresult ;
71159   int result;
71160
71161   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
71162   jresult = (int)result;
71163   return jresult;
71164 }
71165
71166
71167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
71168   int jresult ;
71169   int result;
71170
71171   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
71172   jresult = (int)result;
71173   return jresult;
71174 }
71175
71176
71177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
71178   int jresult ;
71179   int result;
71180
71181   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
71182   jresult = (int)result;
71183   return jresult;
71184 }
71185
71186
71187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
71188   int jresult ;
71189   int result;
71190
71191   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
71192   jresult = (int)result;
71193   return jresult;
71194 }
71195
71196
71197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
71198   int jresult ;
71199   int result;
71200
71201   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
71202   jresult = (int)result;
71203   return jresult;
71204 }
71205
71206
71207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
71208   int jresult ;
71209   int result;
71210
71211   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
71212   jresult = (int)result;
71213   return jresult;
71214 }
71215
71216
71217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
71218   int jresult ;
71219   int result;
71220
71221   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
71222   jresult = (int)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
71228   int jresult ;
71229   int result;
71230
71231   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
71232   jresult = (int)result;
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
71238   int jresult ;
71239   int result;
71240
71241   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
71242   jresult = (int)result;
71243   return jresult;
71244 }
71245
71246
71247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
71248   int jresult ;
71249   int result;
71250
71251   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
71252   jresult = (int)result;
71253   return jresult;
71254 }
71255
71256
71257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
71258   int jresult ;
71259   int result;
71260
71261   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
71262   jresult = (int)result;
71263   return jresult;
71264 }
71265
71266
71267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
71268   int jresult ;
71269   int result;
71270
71271   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
71272   jresult = (int)result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
71278   int jresult ;
71279   int result;
71280
71281   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
71282   jresult = (int)result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
71288   int jresult ;
71289   int result;
71290
71291   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
71292   jresult = (int)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
71298   int jresult ;
71299   int result;
71300
71301   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
71302   jresult = (int)result;
71303   return jresult;
71304 }
71305
71306
71307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
71308   int jresult ;
71309   int result;
71310
71311   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
71312   jresult = (int)result;
71313   return jresult;
71314 }
71315
71316
71317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
71318   void * jresult ;
71319   Dali::Toolkit::ScrollView::Property *result = 0 ;
71320
71321   {
71322     try {
71323       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
71324     } catch (std::out_of_range& e) {
71325       {
71326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71327       };
71328     } catch (std::exception& e) {
71329       {
71330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71335       };
71336     }
71337   }
71338   jresult = (void *)result;
71339   return jresult;
71340 }
71341
71342
71343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
71344   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
71345
71346   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
71347   {
71348     try {
71349       delete arg1;
71350     } catch (std::out_of_range& e) {
71351       {
71352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71353       };
71354     } catch (std::exception& e) {
71355       {
71356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71357       };
71358     } catch (...) {
71359       {
71360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71361       };
71362     }
71363   }
71364 }
71365
71366
71367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
71368   void * jresult ;
71369   Dali::Toolkit::ScrollView *result = 0 ;
71370
71371   {
71372     try {
71373       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
71374     } catch (std::out_of_range& e) {
71375       {
71376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71377       };
71378     } catch (std::exception& e) {
71379       {
71380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71381       };
71382     } catch (...) {
71383       {
71384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71385       };
71386     }
71387   }
71388   jresult = (void *)result;
71389   return jresult;
71390 }
71391
71392
71393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
71394   void * jresult ;
71395   Dali::Toolkit::ScrollView *arg1 = 0 ;
71396   Dali::Toolkit::ScrollView *result = 0 ;
71397
71398   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71399   if (!arg1) {
71400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71401     return 0;
71402   }
71403   {
71404     try {
71405       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
71406     } catch (std::out_of_range& e) {
71407       {
71408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71409       };
71410     } catch (std::exception& e) {
71411       {
71412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71413       };
71414     } catch (...) {
71415       {
71416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71417       };
71418     }
71419   }
71420   jresult = (void *)result;
71421   return jresult;
71422 }
71423
71424
71425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
71426   void * jresult ;
71427   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71428   Dali::Toolkit::ScrollView *arg2 = 0 ;
71429   Dali::Toolkit::ScrollView *result = 0 ;
71430
71431   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71432   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
71433   if (!arg2) {
71434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
71435     return 0;
71436   }
71437   {
71438     try {
71439       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
71440     } catch (std::out_of_range& e) {
71441       {
71442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71443       };
71444     } catch (std::exception& e) {
71445       {
71446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71447       };
71448     } catch (...) {
71449       {
71450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71451       };
71452     }
71453   }
71454   jresult = (void *)result;
71455   return jresult;
71456 }
71457
71458
71459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
71460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71461
71462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71463   {
71464     try {
71465       delete arg1;
71466     } catch (std::out_of_range& e) {
71467       {
71468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71469       };
71470     } catch (std::exception& e) {
71471       {
71472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71473       };
71474     } catch (...) {
71475       {
71476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71477       };
71478     }
71479   }
71480 }
71481
71482
71483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
71484   void * jresult ;
71485   Dali::Toolkit::ScrollView result;
71486
71487   {
71488     try {
71489       result = Dali::Toolkit::ScrollView::New();
71490     } catch (std::out_of_range& e) {
71491       {
71492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (std::exception& e) {
71495       {
71496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71497       };
71498     } catch (...) {
71499       {
71500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71501       };
71502     }
71503   }
71504   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71505   return jresult;
71506 }
71507
71508
71509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
71510   void * jresult ;
71511   Dali::BaseHandle arg1 ;
71512   Dali::BaseHandle *argp1 ;
71513   Dali::Toolkit::ScrollView result;
71514
71515   argp1 = (Dali::BaseHandle *)jarg1;
71516   if (!argp1) {
71517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71518     return 0;
71519   }
71520   arg1 = *argp1;
71521   {
71522     try {
71523       result = Dali::Toolkit::ScrollView::DownCast(arg1);
71524     } catch (std::out_of_range& e) {
71525       {
71526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71527       };
71528     } catch (std::exception& e) {
71529       {
71530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71531       };
71532     } catch (...) {
71533       {
71534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71535       };
71536     }
71537   }
71538   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
71539   return jresult;
71540 }
71541
71542
71543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
71544   void * jresult ;
71545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71546   Dali::AlphaFunction result;
71547
71548   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71549   {
71550     try {
71551       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
71552     } catch (std::out_of_range& e) {
71553       {
71554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71555       };
71556     } catch (std::exception& e) {
71557       {
71558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71559       };
71560     } catch (...) {
71561       {
71562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71563       };
71564     }
71565   }
71566   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71567   return jresult;
71568 }
71569
71570
71571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
71572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71573   Dali::AlphaFunction arg2 ;
71574   Dali::AlphaFunction *argp2 ;
71575
71576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71577   argp2 = (Dali::AlphaFunction *)jarg2;
71578   if (!argp2) {
71579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71580     return ;
71581   }
71582   arg2 = *argp2;
71583   {
71584     try {
71585       (arg1)->SetScrollSnapAlphaFunction(arg2);
71586     } catch (std::out_of_range& e) {
71587       {
71588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71589       };
71590     } catch (std::exception& e) {
71591       {
71592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71593       };
71594     } catch (...) {
71595       {
71596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71597       };
71598     }
71599   }
71600 }
71601
71602
71603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
71604   void * jresult ;
71605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71606   Dali::AlphaFunction result;
71607
71608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71609   {
71610     try {
71611       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
71612     } catch (std::out_of_range& e) {
71613       {
71614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71615       };
71616     } catch (std::exception& e) {
71617       {
71618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71619       };
71620     } catch (...) {
71621       {
71622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71623       };
71624     }
71625   }
71626   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
71627   return jresult;
71628 }
71629
71630
71631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
71632   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71633   Dali::AlphaFunction arg2 ;
71634   Dali::AlphaFunction *argp2 ;
71635
71636   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71637   argp2 = (Dali::AlphaFunction *)jarg2;
71638   if (!argp2) {
71639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71640     return ;
71641   }
71642   arg2 = *argp2;
71643   {
71644     try {
71645       (arg1)->SetScrollFlickAlphaFunction(arg2);
71646     } catch (std::out_of_range& e) {
71647       {
71648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71649       };
71650     } catch (std::exception& e) {
71651       {
71652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71653       };
71654     } catch (...) {
71655       {
71656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71657       };
71658     }
71659   }
71660 }
71661
71662
71663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
71664   float jresult ;
71665   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71666   float result;
71667
71668   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71669   {
71670     try {
71671       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
71672     } catch (std::out_of_range& e) {
71673       {
71674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71675       };
71676     } catch (std::exception& e) {
71677       {
71678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (...) {
71681       {
71682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71683       };
71684     }
71685   }
71686   jresult = result;
71687   return jresult;
71688 }
71689
71690
71691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
71692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71693   float arg2 ;
71694
71695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71696   arg2 = (float)jarg2;
71697   {
71698     try {
71699       (arg1)->SetScrollSnapDuration(arg2);
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71707       };
71708     } catch (...) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71711       };
71712     }
71713   }
71714 }
71715
71716
71717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
71718   float jresult ;
71719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71720   float result;
71721
71722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71723   {
71724     try {
71725       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
71726     } catch (std::out_of_range& e) {
71727       {
71728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71729       };
71730     } catch (std::exception& e) {
71731       {
71732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71733       };
71734     } catch (...) {
71735       {
71736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71737       };
71738     }
71739   }
71740   jresult = result;
71741   return jresult;
71742 }
71743
71744
71745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
71746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71747   float arg2 ;
71748
71749   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71750   arg2 = (float)jarg2;
71751   {
71752     try {
71753       (arg1)->SetScrollFlickDuration(arg2);
71754     } catch (std::out_of_range& e) {
71755       {
71756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71757       };
71758     } catch (std::exception& e) {
71759       {
71760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71761       };
71762     } catch (...) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71765       };
71766     }
71767   }
71768 }
71769
71770
71771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
71772   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71773   Dali::Toolkit::RulerPtr arg2 ;
71774   Dali::Toolkit::RulerPtr *argp2 ;
71775
71776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71777   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71778   if (!argp2) {
71779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71780     return ;
71781   }
71782   arg2 = *argp2;
71783   {
71784     try {
71785       (arg1)->SetRulerX(arg2);
71786     } catch (std::out_of_range& e) {
71787       {
71788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71789       };
71790     } catch (std::exception& e) {
71791       {
71792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71793       };
71794     } catch (...) {
71795       {
71796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71797       };
71798     }
71799   }
71800 }
71801
71802
71803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
71804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71805   Dali::Toolkit::RulerPtr arg2 ;
71806   Dali::Toolkit::RulerPtr *argp2 ;
71807
71808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71809   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
71810   if (!argp2) {
71811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
71812     return ;
71813   }
71814   arg2 = *argp2;
71815   {
71816     try {
71817       (arg1)->SetRulerY(arg2);
71818     } catch (std::out_of_range& e) {
71819       {
71820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71821       };
71822     } catch (std::exception& e) {
71823       {
71824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71829       };
71830     }
71831   }
71832 }
71833
71834
71835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
71836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71837   bool arg2 ;
71838
71839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71840   arg2 = jarg2 ? true : false;
71841   {
71842     try {
71843       (arg1)->SetScrollSensitive(arg2);
71844     } catch (std::out_of_range& e) {
71845       {
71846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71847       };
71848     } catch (std::exception& e) {
71849       {
71850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71851       };
71852     } catch (...) {
71853       {
71854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71855       };
71856     }
71857   }
71858 }
71859
71860
71861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
71862   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71863   float arg2 ;
71864   float arg3 ;
71865
71866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71867   arg2 = (float)jarg2;
71868   arg3 = (float)jarg3;
71869   {
71870     try {
71871       (arg1)->SetMaxOvershoot(arg2,arg3);
71872     } catch (std::out_of_range& e) {
71873       {
71874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71875       };
71876     } catch (std::exception& e) {
71877       {
71878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71879       };
71880     } catch (...) {
71881       {
71882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71883       };
71884     }
71885   }
71886 }
71887
71888
71889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
71890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71891   Dali::AlphaFunction arg2 ;
71892   Dali::AlphaFunction *argp2 ;
71893
71894   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71895   argp2 = (Dali::AlphaFunction *)jarg2;
71896   if (!argp2) {
71897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
71898     return ;
71899   }
71900   arg2 = *argp2;
71901   {
71902     try {
71903       (arg1)->SetSnapOvershootAlphaFunction(arg2);
71904     } catch (std::out_of_range& e) {
71905       {
71906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71907       };
71908     } catch (std::exception& e) {
71909       {
71910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71911       };
71912     } catch (...) {
71913       {
71914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71915       };
71916     }
71917   }
71918 }
71919
71920
71921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
71922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71923   float arg2 ;
71924
71925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71926   arg2 = (float)jarg2;
71927   {
71928     try {
71929       (arg1)->SetSnapOvershootDuration(arg2);
71930     } catch (std::out_of_range& e) {
71931       {
71932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71933       };
71934     } catch (std::exception& e) {
71935       {
71936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71937       };
71938     } catch (...) {
71939       {
71940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71941       };
71942     }
71943   }
71944 }
71945
71946
71947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
71948   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71949   bool arg2 ;
71950
71951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71952   arg2 = jarg2 ? true : false;
71953   {
71954     try {
71955       (arg1)->SetActorAutoSnap(arg2);
71956     } catch (std::out_of_range& e) {
71957       {
71958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71959       };
71960     } catch (std::exception& e) {
71961       {
71962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71963       };
71964     } catch (...) {
71965       {
71966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71967       };
71968     }
71969   }
71970 }
71971
71972
71973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
71974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
71975   bool arg2 ;
71976
71977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
71978   arg2 = jarg2 ? true : false;
71979   {
71980     try {
71981       (arg1)->SetWrapMode(arg2);
71982     } catch (std::out_of_range& e) {
71983       {
71984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71985       };
71986     } catch (std::exception& e) {
71987       {
71988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71989       };
71990     } catch (...) {
71991       {
71992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71993       };
71994     }
71995   }
71996 }
71997
71998
71999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
72000   int jresult ;
72001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72002   int result;
72003
72004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72005   {
72006     try {
72007       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
72008     } catch (std::out_of_range& e) {
72009       {
72010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72011       };
72012     } catch (std::exception& e) {
72013       {
72014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72015       };
72016     } catch (...) {
72017       {
72018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72019       };
72020     }
72021   }
72022   jresult = result;
72023   return jresult;
72024 }
72025
72026
72027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
72028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72029   int arg2 ;
72030
72031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72032   arg2 = (int)jarg2;
72033   {
72034     try {
72035       (arg1)->SetScrollUpdateDistance(arg2);
72036     } catch (std::out_of_range& e) {
72037       {
72038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72039       };
72040     } catch (std::exception& e) {
72041       {
72042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72043       };
72044     } catch (...) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72047       };
72048     }
72049   }
72050 }
72051
72052
72053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
72054   unsigned int jresult ;
72055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72056   bool result;
72057
72058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72059   {
72060     try {
72061       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
72062     } catch (std::out_of_range& e) {
72063       {
72064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72065       };
72066     } catch (std::exception& e) {
72067       {
72068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72069       };
72070     } catch (...) {
72071       {
72072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72073       };
72074     }
72075   }
72076   jresult = result;
72077   return jresult;
72078 }
72079
72080
72081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
72082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72083   bool arg2 ;
72084
72085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72086   arg2 = jarg2 ? true : false;
72087   {
72088     try {
72089       (arg1)->SetAxisAutoLock(arg2);
72090     } catch (std::out_of_range& e) {
72091       {
72092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72093       };
72094     } catch (std::exception& e) {
72095       {
72096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72097       };
72098     } catch (...) {
72099       {
72100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72101       };
72102     }
72103   }
72104 }
72105
72106
72107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
72108   float jresult ;
72109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72110   float result;
72111
72112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72113   {
72114     try {
72115       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
72116     } catch (std::out_of_range& e) {
72117       {
72118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72119       };
72120     } catch (std::exception& e) {
72121       {
72122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72123       };
72124     } catch (...) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72127       };
72128     }
72129   }
72130   jresult = result;
72131   return jresult;
72132 }
72133
72134
72135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
72136   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72137   float arg2 ;
72138
72139   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72140   arg2 = (float)jarg2;
72141   {
72142     try {
72143       (arg1)->SetAxisAutoLockGradient(arg2);
72144     } catch (std::out_of_range& e) {
72145       {
72146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72147       };
72148     } catch (std::exception& e) {
72149       {
72150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72151       };
72152     } catch (...) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72155       };
72156     }
72157   }
72158 }
72159
72160
72161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
72162   float jresult ;
72163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72164   float result;
72165
72166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72167   {
72168     try {
72169       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
72170     } catch (std::out_of_range& e) {
72171       {
72172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72173       };
72174     } catch (std::exception& e) {
72175       {
72176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72177       };
72178     } catch (...) {
72179       {
72180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72181       };
72182     }
72183   }
72184   jresult = result;
72185   return jresult;
72186 }
72187
72188
72189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
72190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72191   float arg2 ;
72192
72193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72194   arg2 = (float)jarg2;
72195   {
72196     try {
72197       (arg1)->SetFrictionCoefficient(arg2);
72198     } catch (std::out_of_range& e) {
72199       {
72200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72201       };
72202     } catch (std::exception& e) {
72203       {
72204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72209       };
72210     }
72211   }
72212 }
72213
72214
72215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
72216   float jresult ;
72217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72218   float result;
72219
72220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72221   {
72222     try {
72223       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
72224     } catch (std::out_of_range& e) {
72225       {
72226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72227       };
72228     } catch (std::exception& e) {
72229       {
72230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72231       };
72232     } catch (...) {
72233       {
72234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72235       };
72236     }
72237   }
72238   jresult = result;
72239   return jresult;
72240 }
72241
72242
72243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
72244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72245   float arg2 ;
72246
72247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72248   arg2 = (float)jarg2;
72249   {
72250     try {
72251       (arg1)->SetFlickSpeedCoefficient(arg2);
72252     } catch (std::out_of_range& e) {
72253       {
72254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72255       };
72256     } catch (std::exception& e) {
72257       {
72258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72259       };
72260     } catch (...) {
72261       {
72262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72263       };
72264     }
72265   }
72266 }
72267
72268
72269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
72270   void * jresult ;
72271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72272   Dali::Vector2 result;
72273
72274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72275   {
72276     try {
72277       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
72278     } catch (std::out_of_range& e) {
72279       {
72280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72281       };
72282     } catch (std::exception& e) {
72283       {
72284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72285       };
72286     } catch (...) {
72287       {
72288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72289       };
72290     }
72291   }
72292   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72293   return jresult;
72294 }
72295
72296
72297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
72298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72299   Dali::Vector2 *arg2 = 0 ;
72300
72301   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72302   arg2 = (Dali::Vector2 *)jarg2;
72303   if (!arg2) {
72304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72305     return ;
72306   }
72307   {
72308     try {
72309       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
72310     } catch (std::out_of_range& e) {
72311       {
72312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72313       };
72314     } catch (std::exception& e) {
72315       {
72316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72317       };
72318     } catch (...) {
72319       {
72320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72321       };
72322     }
72323   }
72324 }
72325
72326
72327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
72328   float jresult ;
72329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72330   float result;
72331
72332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72333   {
72334     try {
72335       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
72336     } catch (std::out_of_range& e) {
72337       {
72338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72339       };
72340     } catch (std::exception& e) {
72341       {
72342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72343       };
72344     } catch (...) {
72345       {
72346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72347       };
72348     }
72349   }
72350   jresult = result;
72351   return jresult;
72352 }
72353
72354
72355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
72356   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72357   float arg2 ;
72358
72359   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72360   arg2 = (float)jarg2;
72361   {
72362     try {
72363       (arg1)->SetMinimumSpeedForFlick(arg2);
72364     } catch (std::out_of_range& e) {
72365       {
72366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (std::exception& e) {
72369       {
72370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72375       };
72376     }
72377   }
72378 }
72379
72380
72381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
72382   float jresult ;
72383   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72384   float result;
72385
72386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72387   {
72388     try {
72389       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
72390     } catch (std::out_of_range& e) {
72391       {
72392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72393       };
72394     } catch (std::exception& e) {
72395       {
72396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (...) {
72399       {
72400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72401       };
72402     }
72403   }
72404   jresult = result;
72405   return jresult;
72406 }
72407
72408
72409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
72410   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72411   float arg2 ;
72412
72413   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72414   arg2 = (float)jarg2;
72415   {
72416     try {
72417       (arg1)->SetMaxFlickSpeed(arg2);
72418     } catch (std::out_of_range& e) {
72419       {
72420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72421       };
72422     } catch (std::exception& e) {
72423       {
72424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72425       };
72426     } catch (...) {
72427       {
72428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72429       };
72430     }
72431   }
72432 }
72433
72434
72435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
72436   void * jresult ;
72437   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72438   Dali::Vector2 result;
72439
72440   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72441   {
72442     try {
72443       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
72444     } catch (std::out_of_range& e) {
72445       {
72446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72447       };
72448     } catch (std::exception& e) {
72449       {
72450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72451       };
72452     } catch (...) {
72453       {
72454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72455       };
72456     }
72457   }
72458   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72459   return jresult;
72460 }
72461
72462
72463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
72464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72465   Dali::Vector2 arg2 ;
72466   Dali::Vector2 *argp2 ;
72467
72468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72469   argp2 = (Dali::Vector2 *)jarg2;
72470   if (!argp2) {
72471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
72472     return ;
72473   }
72474   arg2 = *argp2;
72475   {
72476     try {
72477       (arg1)->SetWheelScrollDistanceStep(arg2);
72478     } catch (std::out_of_range& e) {
72479       {
72480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72481       };
72482     } catch (std::exception& e) {
72483       {
72484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72485       };
72486     } catch (...) {
72487       {
72488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72489       };
72490     }
72491   }
72492 }
72493
72494
72495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
72496   void * jresult ;
72497   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72498   Dali::Vector2 result;
72499
72500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72501   {
72502     try {
72503       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
72504     } catch (std::out_of_range& e) {
72505       {
72506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72507       };
72508     } catch (std::exception& e) {
72509       {
72510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (...) {
72513       {
72514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72515       };
72516     }
72517   }
72518   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
72519   return jresult;
72520 }
72521
72522
72523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
72524   unsigned int jresult ;
72525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72526   unsigned int result;
72527
72528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72529   {
72530     try {
72531       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
72532     } catch (std::out_of_range& e) {
72533       {
72534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72535       };
72536     } catch (std::exception& e) {
72537       {
72538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72539       };
72540     } catch (...) {
72541       {
72542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72543       };
72544     }
72545   }
72546   jresult = result;
72547   return jresult;
72548 }
72549
72550
72551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
72552   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72553   Dali::Vector2 *arg2 = 0 ;
72554
72555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72556   arg2 = (Dali::Vector2 *)jarg2;
72557   if (!arg2) {
72558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72559     return ;
72560   }
72561   {
72562     try {
72563       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
72564     } catch (std::out_of_range& e) {
72565       {
72566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72567       };
72568     } catch (std::exception& e) {
72569       {
72570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72571       };
72572     } catch (...) {
72573       {
72574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72575       };
72576     }
72577   }
72578 }
72579
72580
72581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
72582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72583   Dali::Vector2 *arg2 = 0 ;
72584   float arg3 ;
72585
72586   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72587   arg2 = (Dali::Vector2 *)jarg2;
72588   if (!arg2) {
72589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72590     return ;
72591   }
72592   arg3 = (float)jarg3;
72593   {
72594     try {
72595       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
72596     } catch (std::out_of_range& e) {
72597       {
72598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72599       };
72600     } catch (std::exception& e) {
72601       {
72602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72603       };
72604     } catch (...) {
72605       {
72606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72607       };
72608     }
72609   }
72610 }
72611
72612
72613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
72614   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72615   Dali::Vector2 *arg2 = 0 ;
72616   float arg3 ;
72617   Dali::AlphaFunction arg4 ;
72618   Dali::AlphaFunction *argp4 ;
72619
72620   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72621   arg2 = (Dali::Vector2 *)jarg2;
72622   if (!arg2) {
72623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72624     return ;
72625   }
72626   arg3 = (float)jarg3;
72627   argp4 = (Dali::AlphaFunction *)jarg4;
72628   if (!argp4) {
72629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72630     return ;
72631   }
72632   arg4 = *argp4;
72633   {
72634     try {
72635       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
72636     } catch (std::out_of_range& e) {
72637       {
72638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72639       };
72640     } catch (std::exception& e) {
72641       {
72642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72643       };
72644     } catch (...) {
72645       {
72646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72647       };
72648     }
72649   }
72650 }
72651
72652
72653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
72654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72655   Dali::Vector2 *arg2 = 0 ;
72656   float arg3 ;
72657   Dali::Toolkit::DirectionBias arg4 ;
72658   Dali::Toolkit::DirectionBias arg5 ;
72659
72660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72661   arg2 = (Dali::Vector2 *)jarg2;
72662   if (!arg2) {
72663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72664     return ;
72665   }
72666   arg3 = (float)jarg3;
72667   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72668   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72669   {
72670     try {
72671       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
72672     } catch (std::out_of_range& e) {
72673       {
72674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72675       };
72676     } catch (std::exception& e) {
72677       {
72678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72679       };
72680     } catch (...) {
72681       {
72682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72683       };
72684     }
72685   }
72686 }
72687
72688
72689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
72690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72691   Dali::Vector2 *arg2 = 0 ;
72692   float arg3 ;
72693   Dali::AlphaFunction arg4 ;
72694   Dali::Toolkit::DirectionBias arg5 ;
72695   Dali::Toolkit::DirectionBias arg6 ;
72696   Dali::AlphaFunction *argp4 ;
72697
72698   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72699   arg2 = (Dali::Vector2 *)jarg2;
72700   if (!arg2) {
72701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
72702     return ;
72703   }
72704   arg3 = (float)jarg3;
72705   argp4 = (Dali::AlphaFunction *)jarg4;
72706   if (!argp4) {
72707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72708     return ;
72709   }
72710   arg4 = *argp4;
72711   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
72712   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
72713   {
72714     try {
72715       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72723       };
72724     } catch (...) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72727       };
72728     }
72729   }
72730 }
72731
72732
72733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
72734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72735   unsigned int arg2 ;
72736
72737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72738   arg2 = (unsigned int)jarg2;
72739   {
72740     try {
72741       (arg1)->ScrollTo(arg2);
72742     } catch (std::out_of_range& e) {
72743       {
72744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72745       };
72746     } catch (std::exception& e) {
72747       {
72748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72749       };
72750     } catch (...) {
72751       {
72752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72753       };
72754     }
72755   }
72756 }
72757
72758
72759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
72760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72761   unsigned int arg2 ;
72762   float arg3 ;
72763
72764   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72765   arg2 = (unsigned int)jarg2;
72766   arg3 = (float)jarg3;
72767   {
72768     try {
72769       (arg1)->ScrollTo(arg2,arg3);
72770     } catch (std::out_of_range& e) {
72771       {
72772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72773       };
72774     } catch (std::exception& e) {
72775       {
72776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72777       };
72778     } catch (...) {
72779       {
72780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72781       };
72782     }
72783   }
72784 }
72785
72786
72787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
72788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72789   unsigned int arg2 ;
72790   float arg3 ;
72791   Dali::Toolkit::DirectionBias arg4 ;
72792
72793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72794   arg2 = (unsigned int)jarg2;
72795   arg3 = (float)jarg3;
72796   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
72797   {
72798     try {
72799       (arg1)->ScrollTo(arg2,arg3,arg4);
72800     } catch (std::out_of_range& e) {
72801       {
72802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72803       };
72804     } catch (std::exception& e) {
72805       {
72806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72807       };
72808     } catch (...) {
72809       {
72810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72811       };
72812     }
72813   }
72814 }
72815
72816
72817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
72818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72819   Dali::Actor *arg2 = 0 ;
72820
72821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72822   arg2 = (Dali::Actor *)jarg2;
72823   if (!arg2) {
72824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72825     return ;
72826   }
72827   {
72828     try {
72829       (arg1)->ScrollTo(*arg2);
72830     } catch (std::out_of_range& e) {
72831       {
72832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72833       };
72834     } catch (std::exception& e) {
72835       {
72836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72837       };
72838     } catch (...) {
72839       {
72840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72841       };
72842     }
72843   }
72844 }
72845
72846
72847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
72848   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72849   Dali::Actor *arg2 = 0 ;
72850   float arg3 ;
72851
72852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72853   arg2 = (Dali::Actor *)jarg2;
72854   if (!arg2) {
72855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72856     return ;
72857   }
72858   arg3 = (float)jarg3;
72859   {
72860     try {
72861       (arg1)->ScrollTo(*arg2,arg3);
72862     } catch (std::out_of_range& e) {
72863       {
72864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72865       };
72866     } catch (std::exception& e) {
72867       {
72868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72869       };
72870     } catch (...) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72873       };
72874     }
72875   }
72876 }
72877
72878
72879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
72880   unsigned int jresult ;
72881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72882   bool result;
72883
72884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72885   {
72886     try {
72887       result = (bool)(arg1)->ScrollToSnapPoint();
72888     } catch (std::out_of_range& e) {
72889       {
72890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72891       };
72892     } catch (std::exception& e) {
72893       {
72894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72895       };
72896     } catch (...) {
72897       {
72898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72899       };
72900     }
72901   }
72902   jresult = result;
72903   return jresult;
72904 }
72905
72906
72907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
72908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72909   Dali::Constraint arg2 ;
72910   Dali::Constraint *argp2 ;
72911
72912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72913   argp2 = (Dali::Constraint *)jarg2;
72914   if (!argp2) {
72915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
72916     return ;
72917   }
72918   arg2 = *argp2;
72919   {
72920     try {
72921       (arg1)->ApplyConstraintToChildren(arg2);
72922     } catch (std::out_of_range& e) {
72923       {
72924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72925       };
72926     } catch (std::exception& e) {
72927       {
72928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72929       };
72930     } catch (...) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72933       };
72934     }
72935   }
72936 }
72937
72938
72939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
72940   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72941
72942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72943   {
72944     try {
72945       (arg1)->RemoveConstraintsFromChildren();
72946     } catch (std::out_of_range& e) {
72947       {
72948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72949       };
72950     } catch (std::exception& e) {
72951       {
72952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72953       };
72954     } catch (...) {
72955       {
72956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72957       };
72958     }
72959   }
72960 }
72961
72962
72963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
72964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72965   Dali::Toolkit::ScrollViewEffect arg2 ;
72966   Dali::Toolkit::ScrollViewEffect *argp2 ;
72967
72968   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72969   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
72970   if (!argp2) {
72971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
72972     return ;
72973   }
72974   arg2 = *argp2;
72975   {
72976     try {
72977       (arg1)->ApplyEffect(arg2);
72978     } catch (std::out_of_range& e) {
72979       {
72980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72981       };
72982     } catch (std::exception& e) {
72983       {
72984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72985       };
72986     } catch (...) {
72987       {
72988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72989       };
72990     }
72991   }
72992 }
72993
72994
72995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
72996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72997   Dali::Toolkit::ScrollViewEffect arg2 ;
72998   Dali::Toolkit::ScrollViewEffect *argp2 ;
72999
73000   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73001   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
73002   if (!argp2) {
73003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
73004     return ;
73005   }
73006   arg2 = *argp2;
73007   {
73008     try {
73009       (arg1)->RemoveEffect(arg2);
73010     } catch (std::out_of_range& e) {
73011       {
73012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73013       };
73014     } catch (std::exception& e) {
73015       {
73016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73017       };
73018     } catch (...) {
73019       {
73020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73021       };
73022     }
73023   }
73024 }
73025
73026
73027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
73028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73029
73030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73031   {
73032     try {
73033       (arg1)->RemoveAllEffects();
73034     } catch (std::out_of_range& e) {
73035       {
73036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73037       };
73038     } catch (std::exception& e) {
73039       {
73040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73041       };
73042     } catch (...) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73045       };
73046     }
73047   }
73048 }
73049
73050
73051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
73052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73053   Dali::Actor arg2 ;
73054   Dali::Actor *argp2 ;
73055
73056   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73057   argp2 = (Dali::Actor *)jarg2;
73058   if (!argp2) {
73059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73060     return ;
73061   }
73062   arg2 = *argp2;
73063   {
73064     try {
73065       (arg1)->BindActor(arg2);
73066     } catch (std::out_of_range& e) {
73067       {
73068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73069       };
73070     } catch (std::exception& e) {
73071       {
73072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73073       };
73074     } catch (...) {
73075       {
73076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73077       };
73078     }
73079   }
73080 }
73081
73082
73083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
73084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73085   Dali::Actor arg2 ;
73086   Dali::Actor *argp2 ;
73087
73088   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73089   argp2 = (Dali::Actor *)jarg2;
73090   if (!argp2) {
73091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73092     return ;
73093   }
73094   arg2 = *argp2;
73095   {
73096     try {
73097       (arg1)->UnbindActor(arg2);
73098     } catch (std::out_of_range& e) {
73099       {
73100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73101       };
73102     } catch (std::exception& e) {
73103       {
73104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73105       };
73106     } catch (...) {
73107       {
73108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73109       };
73110     }
73111   }
73112 }
73113
73114
73115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
73116   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73117   Dali::Radian arg2 ;
73118   Dali::Radian arg3 ;
73119   Dali::Radian *argp2 ;
73120   Dali::Radian *argp3 ;
73121
73122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73123   argp2 = (Dali::Radian *)jarg2;
73124   if (!argp2) {
73125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73126     return ;
73127   }
73128   arg2 = *argp2;
73129   argp3 = (Dali::Radian *)jarg3;
73130   if (!argp3) {
73131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73132     return ;
73133   }
73134   arg3 = *argp3;
73135   {
73136     try {
73137       (arg1)->SetScrollingDirection(arg2,arg3);
73138     } catch (std::out_of_range& e) {
73139       {
73140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73141       };
73142     } catch (std::exception& e) {
73143       {
73144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73145       };
73146     } catch (...) {
73147       {
73148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73149       };
73150     }
73151   }
73152 }
73153
73154
73155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
73156   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73157   Dali::Radian arg2 ;
73158   Dali::Radian *argp2 ;
73159
73160   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73161   argp2 = (Dali::Radian *)jarg2;
73162   if (!argp2) {
73163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73164     return ;
73165   }
73166   arg2 = *argp2;
73167   {
73168     try {
73169       (arg1)->SetScrollingDirection(arg2);
73170     } catch (std::out_of_range& e) {
73171       {
73172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73173       };
73174     } catch (std::exception& e) {
73175       {
73176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73177       };
73178     } catch (...) {
73179       {
73180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73181       };
73182     }
73183   }
73184 }
73185
73186
73187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
73188   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73189   Dali::Radian arg2 ;
73190   Dali::Radian *argp2 ;
73191
73192   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73193   argp2 = (Dali::Radian *)jarg2;
73194   if (!argp2) {
73195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
73196     return ;
73197   }
73198   arg2 = *argp2;
73199   {
73200     try {
73201       (arg1)->RemoveScrollingDirection(arg2);
73202     } catch (std::out_of_range& e) {
73203       {
73204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73205       };
73206     } catch (std::exception& e) {
73207       {
73208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73209       };
73210     } catch (...) {
73211       {
73212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73213       };
73214     }
73215   }
73216 }
73217
73218
73219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
73220   void * jresult ;
73221   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73222   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
73223
73224   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73225   {
73226     try {
73227       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
73228     } catch (std::out_of_range& e) {
73229       {
73230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (std::exception& e) {
73233       {
73234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73239       };
73240     }
73241   }
73242   jresult = (void *)result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
73248   int jresult ;
73249   int result;
73250
73251   result = (int)Dali::Toolkit::TableView::Property::ROWS;
73252   jresult = (int)result;
73253   return jresult;
73254 }
73255
73256
73257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
73258   int jresult ;
73259   int result;
73260
73261   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
73262   jresult = (int)result;
73263   return jresult;
73264 }
73265
73266
73267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
73268   int jresult ;
73269   int result;
73270
73271   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
73272   jresult = (int)result;
73273   return jresult;
73274 }
73275
73276
73277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
73278   int jresult ;
73279   int result;
73280
73281   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
73282   jresult = (int)result;
73283   return jresult;
73284 }
73285
73286
73287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
73288   int jresult ;
73289   int result;
73290
73291   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
73292   jresult = (int)result;
73293   return jresult;
73294 }
73295
73296
73297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
73298   void * jresult ;
73299   Dali::Toolkit::TableView::Property *result = 0 ;
73300
73301   {
73302     try {
73303       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
73304     } catch (std::out_of_range& e) {
73305       {
73306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73307       };
73308     } catch (std::exception& e) {
73309       {
73310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73311       };
73312     } catch (...) {
73313       {
73314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73315       };
73316     }
73317   }
73318   jresult = (void *)result;
73319   return jresult;
73320 }
73321
73322
73323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
73324   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
73325
73326   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
73327   {
73328     try {
73329       delete arg1;
73330     } catch (std::out_of_range& e) {
73331       {
73332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73333       };
73334     } catch (std::exception& e) {
73335       {
73336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73337       };
73338     } catch (...) {
73339       {
73340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73341       };
73342     }
73343   }
73344 }
73345
73346
73347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
73348   int jresult ;
73349   int result;
73350
73351   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
73352   jresult = (int)result;
73353   return jresult;
73354 }
73355
73356
73357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
73358   int jresult ;
73359   int result;
73360
73361   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
73362   jresult = (int)result;
73363   return jresult;
73364 }
73365
73366
73367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
73368   int jresult ;
73369   int result;
73370
73371   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
73372   jresult = (int)result;
73373   return jresult;
73374 }
73375
73376
73377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
73378   int jresult ;
73379   int result;
73380
73381   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
73382   jresult = (int)result;
73383   return jresult;
73384 }
73385
73386
73387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
73388   int jresult ;
73389   int result;
73390
73391   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
73392   jresult = (int)result;
73393   return jresult;
73394 }
73395
73396
73397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
73398   void * jresult ;
73399   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
73400
73401   {
73402     try {
73403       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
73404     } catch (std::out_of_range& e) {
73405       {
73406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73407       };
73408     } catch (std::exception& e) {
73409       {
73410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73411       };
73412     } catch (...) {
73413       {
73414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73415       };
73416     }
73417   }
73418   jresult = (void *)result;
73419   return jresult;
73420 }
73421
73422
73423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
73424   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
73425
73426   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
73427   {
73428     try {
73429       delete arg1;
73430     } catch (std::out_of_range& e) {
73431       {
73432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73433       };
73434     } catch (std::exception& e) {
73435       {
73436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73437       };
73438     } catch (...) {
73439       {
73440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73441       };
73442     }
73443   }
73444 }
73445
73446
73447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
73448   void * jresult ;
73449   unsigned int arg1 ;
73450   unsigned int arg2 ;
73451   unsigned int arg3 ;
73452   unsigned int arg4 ;
73453   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73454
73455   arg1 = (unsigned int)jarg1;
73456   arg2 = (unsigned int)jarg2;
73457   arg3 = (unsigned int)jarg3;
73458   arg4 = (unsigned int)jarg4;
73459   {
73460     try {
73461       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
73462     } catch (std::out_of_range& e) {
73463       {
73464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73465       };
73466     } catch (std::exception& e) {
73467       {
73468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73469       };
73470     } catch (...) {
73471       {
73472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73473       };
73474     }
73475   }
73476   jresult = (void *)result;
73477   return jresult;
73478 }
73479
73480
73481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
73482   void * jresult ;
73483   unsigned int arg1 ;
73484   unsigned int arg2 ;
73485   unsigned int arg3 ;
73486   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73487
73488   arg1 = (unsigned int)jarg1;
73489   arg2 = (unsigned int)jarg2;
73490   arg3 = (unsigned int)jarg3;
73491   {
73492     try {
73493       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
73494     } catch (std::out_of_range& e) {
73495       {
73496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73497       };
73498     } catch (std::exception& e) {
73499       {
73500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73501       };
73502     } catch (...) {
73503       {
73504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73505       };
73506     }
73507   }
73508   jresult = (void *)result;
73509   return jresult;
73510 }
73511
73512
73513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
73514   void * jresult ;
73515   unsigned int arg1 ;
73516   unsigned int arg2 ;
73517   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73518
73519   arg1 = (unsigned int)jarg1;
73520   arg2 = (unsigned int)jarg2;
73521   {
73522     try {
73523       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
73524     } catch (std::out_of_range& e) {
73525       {
73526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (std::exception& e) {
73529       {
73530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73531       };
73532     } catch (...) {
73533       {
73534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73535       };
73536     }
73537   }
73538   jresult = (void *)result;
73539   return jresult;
73540 }
73541
73542
73543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
73544   void * jresult ;
73545   unsigned int arg1 ;
73546   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73547
73548   arg1 = (unsigned int)jarg1;
73549   {
73550     try {
73551       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
73552     } catch (std::out_of_range& e) {
73553       {
73554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73555       };
73556     } catch (std::exception& e) {
73557       {
73558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (...) {
73561       {
73562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73563       };
73564     }
73565   }
73566   jresult = (void *)result;
73567   return jresult;
73568 }
73569
73570
73571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
73572   void * jresult ;
73573   Dali::Toolkit::TableView::CellPosition *result = 0 ;
73574
73575   {
73576     try {
73577       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73585       };
73586     } catch (...) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73589       };
73590     }
73591   }
73592   jresult = (void *)result;
73593   return jresult;
73594 }
73595
73596
73597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
73598   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73599   unsigned int arg2 ;
73600
73601   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73602   arg2 = (unsigned int)jarg2;
73603   if (arg1) (arg1)->rowIndex = arg2;
73604 }
73605
73606
73607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
73608   unsigned int jresult ;
73609   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73610   unsigned int result;
73611
73612   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73613   result = (unsigned int) ((arg1)->rowIndex);
73614   jresult = result;
73615   return jresult;
73616 }
73617
73618
73619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
73620   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73621   unsigned int arg2 ;
73622
73623   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73624   arg2 = (unsigned int)jarg2;
73625   if (arg1) (arg1)->columnIndex = arg2;
73626 }
73627
73628
73629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
73630   unsigned int jresult ;
73631   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73632   unsigned int result;
73633
73634   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73635   result = (unsigned int) ((arg1)->columnIndex);
73636   jresult = result;
73637   return jresult;
73638 }
73639
73640
73641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
73642   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73643   unsigned int arg2 ;
73644
73645   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73646   arg2 = (unsigned int)jarg2;
73647   if (arg1) (arg1)->rowSpan = arg2;
73648 }
73649
73650
73651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
73652   unsigned int jresult ;
73653   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73654   unsigned int result;
73655
73656   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73657   result = (unsigned int) ((arg1)->rowSpan);
73658   jresult = result;
73659   return jresult;
73660 }
73661
73662
73663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
73664   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73665   unsigned int arg2 ;
73666
73667   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73668   arg2 = (unsigned int)jarg2;
73669   if (arg1) (arg1)->columnSpan = arg2;
73670 }
73671
73672
73673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
73674   unsigned int jresult ;
73675   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73676   unsigned int result;
73677
73678   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73679   result = (unsigned int) ((arg1)->columnSpan);
73680   jresult = result;
73681   return jresult;
73682 }
73683
73684
73685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
73686   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
73687
73688   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
73689   {
73690     try {
73691       delete arg1;
73692     } catch (std::out_of_range& e) {
73693       {
73694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73695       };
73696     } catch (std::exception& e) {
73697       {
73698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73699       };
73700     } catch (...) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73703       };
73704     }
73705   }
73706 }
73707
73708
73709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
73710   void * jresult ;
73711   Dali::Toolkit::TableView *result = 0 ;
73712
73713   {
73714     try {
73715       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
73716     } catch (std::out_of_range& e) {
73717       {
73718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73719       };
73720     } catch (std::exception& e) {
73721       {
73722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73723       };
73724     } catch (...) {
73725       {
73726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73727       };
73728     }
73729   }
73730   jresult = (void *)result;
73731   return jresult;
73732 }
73733
73734
73735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
73736   void * jresult ;
73737   Dali::Toolkit::TableView *arg1 = 0 ;
73738   Dali::Toolkit::TableView *result = 0 ;
73739
73740   arg1 = (Dali::Toolkit::TableView *)jarg1;
73741   if (!arg1) {
73742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73743     return 0;
73744   }
73745   {
73746     try {
73747       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
73748     } catch (std::out_of_range& e) {
73749       {
73750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73751       };
73752     } catch (std::exception& e) {
73753       {
73754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73755       };
73756     } catch (...) {
73757       {
73758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73759       };
73760     }
73761   }
73762   jresult = (void *)result;
73763   return jresult;
73764 }
73765
73766
73767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
73768   void * jresult ;
73769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73770   Dali::Toolkit::TableView *arg2 = 0 ;
73771   Dali::Toolkit::TableView *result = 0 ;
73772
73773   arg1 = (Dali::Toolkit::TableView *)jarg1;
73774   arg2 = (Dali::Toolkit::TableView *)jarg2;
73775   if (!arg2) {
73776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
73777     return 0;
73778   }
73779   {
73780     try {
73781       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
73782     } catch (std::out_of_range& e) {
73783       {
73784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73785       };
73786     } catch (std::exception& e) {
73787       {
73788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73789       };
73790     } catch (...) {
73791       {
73792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73793       };
73794     }
73795   }
73796   jresult = (void *)result;
73797   return jresult;
73798 }
73799
73800
73801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
73802   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73803
73804   arg1 = (Dali::Toolkit::TableView *)jarg1;
73805   {
73806     try {
73807       delete arg1;
73808     } catch (std::out_of_range& e) {
73809       {
73810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73811       };
73812     } catch (std::exception& e) {
73813       {
73814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73815       };
73816     } catch (...) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73819       };
73820     }
73821   }
73822 }
73823
73824
73825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
73826   void * jresult ;
73827   unsigned int arg1 ;
73828   unsigned int arg2 ;
73829   Dali::Toolkit::TableView result;
73830
73831   arg1 = (unsigned int)jarg1;
73832   arg2 = (unsigned int)jarg2;
73833   {
73834     try {
73835       result = Dali::Toolkit::TableView::New(arg1,arg2);
73836     } catch (std::out_of_range& e) {
73837       {
73838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73839       };
73840     } catch (std::exception& e) {
73841       {
73842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73843       };
73844     } catch (...) {
73845       {
73846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73847       };
73848     }
73849   }
73850   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73851   return jresult;
73852 }
73853
73854
73855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
73856   void * jresult ;
73857   Dali::BaseHandle arg1 ;
73858   Dali::BaseHandle *argp1 ;
73859   Dali::Toolkit::TableView result;
73860
73861   argp1 = (Dali::BaseHandle *)jarg1;
73862   if (!argp1) {
73863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73864     return 0;
73865   }
73866   arg1 = *argp1;
73867   {
73868     try {
73869       result = Dali::Toolkit::TableView::DownCast(arg1);
73870     } catch (std::out_of_range& e) {
73871       {
73872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73873       };
73874     } catch (std::exception& e) {
73875       {
73876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73877       };
73878     } catch (...) {
73879       {
73880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73881       };
73882     }
73883   }
73884   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
73885   return jresult;
73886 }
73887
73888
73889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
73890   unsigned int jresult ;
73891   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73892   Dali::Actor arg2 ;
73893   Dali::Toolkit::TableView::CellPosition arg3 ;
73894   Dali::Actor *argp2 ;
73895   Dali::Toolkit::TableView::CellPosition *argp3 ;
73896   bool result;
73897
73898   arg1 = (Dali::Toolkit::TableView *)jarg1;
73899   argp2 = (Dali::Actor *)jarg2;
73900   if (!argp2) {
73901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73902     return 0;
73903   }
73904   arg2 = *argp2;
73905   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
73906   if (!argp3) {
73907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73908     return 0;
73909   }
73910   arg3 = *argp3;
73911   {
73912     try {
73913       result = (bool)(arg1)->AddChild(arg2,arg3);
73914     } catch (std::out_of_range& e) {
73915       {
73916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73917       };
73918     } catch (std::exception& e) {
73919       {
73920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73921       };
73922     } catch (...) {
73923       {
73924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73925       };
73926     }
73927   }
73928   jresult = result;
73929   return jresult;
73930 }
73931
73932
73933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
73934   void * jresult ;
73935   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73936   Dali::Toolkit::TableView::CellPosition arg2 ;
73937   Dali::Toolkit::TableView::CellPosition *argp2 ;
73938   Dali::Actor result;
73939
73940   arg1 = (Dali::Toolkit::TableView *)jarg1;
73941   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73942   if (!argp2) {
73943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73944     return 0;
73945   }
73946   arg2 = *argp2;
73947   {
73948     try {
73949       result = (arg1)->GetChildAt(arg2);
73950     } catch (std::out_of_range& e) {
73951       {
73952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73953       };
73954     } catch (std::exception& e) {
73955       {
73956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73957       };
73958     } catch (...) {
73959       {
73960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73961       };
73962     }
73963   }
73964   jresult = new Dali::Actor((const Dali::Actor &)result);
73965   return jresult;
73966 }
73967
73968
73969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
73970   void * jresult ;
73971   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
73972   Dali::Toolkit::TableView::CellPosition arg2 ;
73973   Dali::Toolkit::TableView::CellPosition *argp2 ;
73974   Dali::Actor result;
73975
73976   arg1 = (Dali::Toolkit::TableView *)jarg1;
73977   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
73978   if (!argp2) {
73979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
73980     return 0;
73981   }
73982   arg2 = *argp2;
73983   {
73984     try {
73985       result = (arg1)->RemoveChildAt(arg2);
73986     } catch (std::out_of_range& e) {
73987       {
73988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73989       };
73990     } catch (std::exception& e) {
73991       {
73992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73993       };
73994     } catch (...) {
73995       {
73996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73997       };
73998     }
73999   }
74000   jresult = new Dali::Actor((const Dali::Actor &)result);
74001   return jresult;
74002 }
74003
74004
74005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
74006   unsigned int jresult ;
74007   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74008   Dali::Actor arg2 ;
74009   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
74010   Dali::Actor *argp2 ;
74011   bool result;
74012
74013   arg1 = (Dali::Toolkit::TableView *)jarg1;
74014   argp2 = (Dali::Actor *)jarg2;
74015   if (!argp2) {
74016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74017     return 0;
74018   }
74019   arg2 = *argp2;
74020   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
74021   if (!arg3) {
74022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
74023     return 0;
74024   }
74025   {
74026     try {
74027       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
74028     } catch (std::out_of_range& e) {
74029       {
74030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74031       };
74032     } catch (std::exception& e) {
74033       {
74034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74035       };
74036     } catch (...) {
74037       {
74038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74039       };
74040     }
74041   }
74042   jresult = result;
74043   return jresult;
74044 }
74045
74046
74047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
74048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74049   unsigned int arg2 ;
74050
74051   arg1 = (Dali::Toolkit::TableView *)jarg1;
74052   arg2 = (unsigned int)jarg2;
74053   {
74054     try {
74055       (arg1)->InsertRow(arg2);
74056     } catch (std::out_of_range& e) {
74057       {
74058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74059       };
74060     } catch (std::exception& e) {
74061       {
74062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74063       };
74064     } catch (...) {
74065       {
74066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74067       };
74068     }
74069   }
74070 }
74071
74072
74073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
74074   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74075   unsigned int arg2 ;
74076
74077   arg1 = (Dali::Toolkit::TableView *)jarg1;
74078   arg2 = (unsigned int)jarg2;
74079   {
74080     try {
74081       (arg1)->DeleteRow(arg2);
74082     } catch (std::out_of_range& e) {
74083       {
74084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74085       };
74086     } catch (std::exception& e) {
74087       {
74088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74089       };
74090     } catch (...) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74093       };
74094     }
74095   }
74096 }
74097
74098
74099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
74100   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74101   unsigned int arg2 ;
74102   std::vector< Dali::Actor > *arg3 = 0 ;
74103
74104   arg1 = (Dali::Toolkit::TableView *)jarg1;
74105   arg2 = (unsigned int)jarg2;
74106   arg3 = (std::vector< Dali::Actor > *)jarg3;
74107   if (!arg3) {
74108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74109     return ;
74110   }
74111   {
74112     try {
74113       (arg1)->DeleteRow(arg2,*arg3);
74114     } catch (std::out_of_range& e) {
74115       {
74116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74117       };
74118     } catch (std::exception& e) {
74119       {
74120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74121       };
74122     } catch (...) {
74123       {
74124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74125       };
74126     }
74127   }
74128 }
74129
74130
74131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
74132   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74133   unsigned int arg2 ;
74134
74135   arg1 = (Dali::Toolkit::TableView *)jarg1;
74136   arg2 = (unsigned int)jarg2;
74137   {
74138     try {
74139       (arg1)->InsertColumn(arg2);
74140     } catch (std::out_of_range& e) {
74141       {
74142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74143       };
74144     } catch (std::exception& e) {
74145       {
74146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74147       };
74148     } catch (...) {
74149       {
74150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74151       };
74152     }
74153   }
74154 }
74155
74156
74157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
74158   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74159   unsigned int arg2 ;
74160
74161   arg1 = (Dali::Toolkit::TableView *)jarg1;
74162   arg2 = (unsigned int)jarg2;
74163   {
74164     try {
74165       (arg1)->DeleteColumn(arg2);
74166     } catch (std::out_of_range& e) {
74167       {
74168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74169       };
74170     } catch (std::exception& e) {
74171       {
74172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74173       };
74174     } catch (...) {
74175       {
74176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74177       };
74178     }
74179   }
74180 }
74181
74182
74183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
74184   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74185   unsigned int arg2 ;
74186   std::vector< Dali::Actor > *arg3 = 0 ;
74187
74188   arg1 = (Dali::Toolkit::TableView *)jarg1;
74189   arg2 = (unsigned int)jarg2;
74190   arg3 = (std::vector< Dali::Actor > *)jarg3;
74191   if (!arg3) {
74192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74193     return ;
74194   }
74195   {
74196     try {
74197       (arg1)->DeleteColumn(arg2,*arg3);
74198     } catch (std::out_of_range& e) {
74199       {
74200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74201       };
74202     } catch (std::exception& e) {
74203       {
74204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74205       };
74206     } catch (...) {
74207       {
74208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74209       };
74210     }
74211   }
74212 }
74213
74214
74215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
74216   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74217   unsigned int arg2 ;
74218   unsigned int arg3 ;
74219
74220   arg1 = (Dali::Toolkit::TableView *)jarg1;
74221   arg2 = (unsigned int)jarg2;
74222   arg3 = (unsigned int)jarg3;
74223   {
74224     try {
74225       (arg1)->Resize(arg2,arg3);
74226     } catch (std::out_of_range& e) {
74227       {
74228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74229       };
74230     } catch (std::exception& e) {
74231       {
74232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74233       };
74234     } catch (...) {
74235       {
74236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74237       };
74238     }
74239   }
74240 }
74241
74242
74243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
74244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74245   unsigned int arg2 ;
74246   unsigned int arg3 ;
74247   std::vector< Dali::Actor > *arg4 = 0 ;
74248
74249   arg1 = (Dali::Toolkit::TableView *)jarg1;
74250   arg2 = (unsigned int)jarg2;
74251   arg3 = (unsigned int)jarg3;
74252   arg4 = (std::vector< Dali::Actor > *)jarg4;
74253   if (!arg4) {
74254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
74255     return ;
74256   }
74257   {
74258     try {
74259       (arg1)->Resize(arg2,arg3,*arg4);
74260     } catch (std::out_of_range& e) {
74261       {
74262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74263       };
74264     } catch (std::exception& e) {
74265       {
74266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74267       };
74268     } catch (...) {
74269       {
74270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74271       };
74272     }
74273   }
74274 }
74275
74276
74277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
74278   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74279   Dali::Size arg2 ;
74280   Dali::Size *argp2 ;
74281
74282   arg1 = (Dali::Toolkit::TableView *)jarg1;
74283   argp2 = (Dali::Size *)jarg2;
74284   if (!argp2) {
74285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
74286     return ;
74287   }
74288   arg2 = *argp2;
74289   {
74290     try {
74291       (arg1)->SetCellPadding(arg2);
74292     } catch (std::out_of_range& e) {
74293       {
74294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74295       };
74296     } catch (std::exception& e) {
74297       {
74298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74299       };
74300     } catch (...) {
74301       {
74302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74303       };
74304     }
74305   }
74306 }
74307
74308
74309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
74310   void * jresult ;
74311   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74312   Dali::Size result;
74313
74314   arg1 = (Dali::Toolkit::TableView *)jarg1;
74315   {
74316     try {
74317       result = (arg1)->GetCellPadding();
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 = new Dali::Size((const Dali::Size &)result);
74333   return jresult;
74334 }
74335
74336
74337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
74338   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74339   unsigned int arg2 ;
74340
74341   arg1 = (Dali::Toolkit::TableView *)jarg1;
74342   arg2 = (unsigned int)jarg2;
74343   {
74344     try {
74345       (arg1)->SetFitHeight(arg2);
74346     } catch (std::out_of_range& e) {
74347       {
74348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74349       };
74350     } catch (std::exception& e) {
74351       {
74352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74353       };
74354     } catch (...) {
74355       {
74356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74357       };
74358     }
74359   }
74360 }
74361
74362
74363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
74364   unsigned int jresult ;
74365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74366   unsigned int arg2 ;
74367   bool result;
74368
74369   arg1 = (Dali::Toolkit::TableView *)jarg1;
74370   arg2 = (unsigned int)jarg2;
74371   {
74372     try {
74373       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
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 = result;
74389   return jresult;
74390 }
74391
74392
74393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
74394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74395   unsigned int arg2 ;
74396
74397   arg1 = (Dali::Toolkit::TableView *)jarg1;
74398   arg2 = (unsigned int)jarg2;
74399   {
74400     try {
74401       (arg1)->SetFitWidth(arg2);
74402     } catch (std::out_of_range& e) {
74403       {
74404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74405       };
74406     } catch (std::exception& e) {
74407       {
74408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74409       };
74410     } catch (...) {
74411       {
74412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74413       };
74414     }
74415   }
74416 }
74417
74418
74419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
74420   unsigned int jresult ;
74421   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74422   unsigned int arg2 ;
74423   bool result;
74424
74425   arg1 = (Dali::Toolkit::TableView *)jarg1;
74426   arg2 = (unsigned int)jarg2;
74427   {
74428     try {
74429       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
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 = result;
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74450   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74451   unsigned int arg2 ;
74452   float arg3 ;
74453
74454   arg1 = (Dali::Toolkit::TableView *)jarg1;
74455   arg2 = (unsigned int)jarg2;
74456   arg3 = (float)jarg3;
74457   {
74458     try {
74459       (arg1)->SetFixedHeight(arg2,arg3);
74460     } catch (std::out_of_range& e) {
74461       {
74462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74463       };
74464     } catch (std::exception& e) {
74465       {
74466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74467       };
74468     } catch (...) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74471       };
74472     }
74473   }
74474 }
74475
74476
74477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
74478   float jresult ;
74479   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74480   unsigned int arg2 ;
74481   float result;
74482
74483   arg1 = (Dali::Toolkit::TableView *)jarg1;
74484   arg2 = (unsigned int)jarg2;
74485   {
74486     try {
74487       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
74488     } catch (std::out_of_range& e) {
74489       {
74490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74491       };
74492     } catch (std::exception& e) {
74493       {
74494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74495       };
74496     } catch (...) {
74497       {
74498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74499       };
74500     }
74501   }
74502   jresult = result;
74503   return jresult;
74504 }
74505
74506
74507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
74508   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74509   unsigned int arg2 ;
74510   float arg3 ;
74511
74512   arg1 = (Dali::Toolkit::TableView *)jarg1;
74513   arg2 = (unsigned int)jarg2;
74514   arg3 = (float)jarg3;
74515   {
74516     try {
74517       (arg1)->SetRelativeHeight(arg2,arg3);
74518     } catch (std::out_of_range& e) {
74519       {
74520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74521       };
74522     } catch (std::exception& e) {
74523       {
74524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74525       };
74526     } catch (...) {
74527       {
74528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74529       };
74530     }
74531   }
74532 }
74533
74534
74535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
74536   float jresult ;
74537   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74538   unsigned int arg2 ;
74539   float result;
74540
74541   arg1 = (Dali::Toolkit::TableView *)jarg1;
74542   arg2 = (unsigned int)jarg2;
74543   {
74544     try {
74545       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
74546     } catch (std::out_of_range& e) {
74547       {
74548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74549       };
74550     } catch (std::exception& e) {
74551       {
74552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74553       };
74554     } catch (...) {
74555       {
74556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74557       };
74558     }
74559   }
74560   jresult = result;
74561   return jresult;
74562 }
74563
74564
74565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74566   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74567   unsigned int arg2 ;
74568   float arg3 ;
74569
74570   arg1 = (Dali::Toolkit::TableView *)jarg1;
74571   arg2 = (unsigned int)jarg2;
74572   arg3 = (float)jarg3;
74573   {
74574     try {
74575       (arg1)->SetFixedWidth(arg2,arg3);
74576     } catch (std::out_of_range& e) {
74577       {
74578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74579       };
74580     } catch (std::exception& e) {
74581       {
74582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74583       };
74584     } catch (...) {
74585       {
74586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74587       };
74588     }
74589   }
74590 }
74591
74592
74593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
74594   float jresult ;
74595   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74596   unsigned int arg2 ;
74597   float result;
74598
74599   arg1 = (Dali::Toolkit::TableView *)jarg1;
74600   arg2 = (unsigned int)jarg2;
74601   {
74602     try {
74603       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
74604     } catch (std::out_of_range& e) {
74605       {
74606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74607       };
74608     } catch (std::exception& e) {
74609       {
74610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74611       };
74612     } catch (...) {
74613       {
74614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74615       };
74616     }
74617   }
74618   jresult = result;
74619   return jresult;
74620 }
74621
74622
74623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
74624   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74625   unsigned int arg2 ;
74626   float arg3 ;
74627
74628   arg1 = (Dali::Toolkit::TableView *)jarg1;
74629   arg2 = (unsigned int)jarg2;
74630   arg3 = (float)jarg3;
74631   {
74632     try {
74633       (arg1)->SetRelativeWidth(arg2,arg3);
74634     } catch (std::out_of_range& e) {
74635       {
74636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74637       };
74638     } catch (std::exception& e) {
74639       {
74640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74641       };
74642     } catch (...) {
74643       {
74644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74645       };
74646     }
74647   }
74648 }
74649
74650
74651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
74652   float jresult ;
74653   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74654   unsigned int arg2 ;
74655   float result;
74656
74657   arg1 = (Dali::Toolkit::TableView *)jarg1;
74658   arg2 = (unsigned int)jarg2;
74659   {
74660     try {
74661       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
74662     } catch (std::out_of_range& e) {
74663       {
74664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (std::exception& e) {
74667       {
74668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74673       };
74674     }
74675   }
74676   jresult = result;
74677   return jresult;
74678 }
74679
74680
74681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
74682   unsigned int jresult ;
74683   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74684   unsigned int result;
74685
74686   arg1 = (Dali::Toolkit::TableView *)jarg1;
74687   {
74688     try {
74689       result = (unsigned int)(arg1)->GetRows();
74690     } catch (std::out_of_range& e) {
74691       {
74692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74693       };
74694     } catch (std::exception& e) {
74695       {
74696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74697       };
74698     } catch (...) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74701       };
74702     }
74703   }
74704   jresult = result;
74705   return jresult;
74706 }
74707
74708
74709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
74710   unsigned int jresult ;
74711   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74712   unsigned int result;
74713
74714   arg1 = (Dali::Toolkit::TableView *)jarg1;
74715   {
74716     try {
74717       result = (unsigned int)(arg1)->GetColumns();
74718     } catch (std::out_of_range& e) {
74719       {
74720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74721       };
74722     } catch (std::exception& e) {
74723       {
74724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (...) {
74727       {
74728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74729       };
74730     }
74731   }
74732   jresult = result;
74733   return jresult;
74734 }
74735
74736
74737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
74738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
74739   Dali::Toolkit::TableView::CellPosition arg2 ;
74740   Dali::HorizontalAlignment::Type arg3 ;
74741   Dali::VerticalAlignment::Type arg4 ;
74742   Dali::Toolkit::TableView::CellPosition *argp2 ;
74743
74744   arg1 = (Dali::Toolkit::TableView *)jarg1;
74745   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
74746   if (!argp2) {
74747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
74748     return ;
74749   }
74750   arg2 = *argp2;
74751   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
74752   arg4 = (Dali::VerticalAlignment::Type)jarg4;
74753   {
74754     try {
74755       (arg1)->SetCellAlignment(arg2,arg3,arg4);
74756     } catch (std::out_of_range& e) {
74757       {
74758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74759       };
74760     } catch (std::exception& e) {
74761       {
74762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74763       };
74764     } catch (...) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74767       };
74768     }
74769   }
74770 }
74771
74772
74773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
74774   unsigned int jresult ;
74775   unsigned int result;
74776
74777   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
74778   jresult = result;
74779   return jresult;
74780 }
74781
74782
74783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
74784   int jresult ;
74785   int result;
74786
74787   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
74788   jresult = (int)result;
74789   return jresult;
74790 }
74791
74792
74793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
74794   int jresult ;
74795   int result;
74796
74797   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
74798   jresult = (int)result;
74799   return jresult;
74800 }
74801
74802
74803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
74804   int jresult ;
74805   int result;
74806
74807   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
74808   jresult = (int)result;
74809   return jresult;
74810 }
74811
74812
74813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
74814   int jresult ;
74815   int result;
74816
74817   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
74818   jresult = (int)result;
74819   return jresult;
74820 }
74821
74822
74823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
74824   int jresult ;
74825   int result;
74826
74827   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
74828   jresult = (int)result;
74829   return jresult;
74830 }
74831
74832
74833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
74834   int jresult ;
74835   int result;
74836
74837   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
74838   jresult = (int)result;
74839   return jresult;
74840 }
74841
74842
74843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
74844   int jresult ;
74845   int result;
74846
74847   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
74848   jresult = (int)result;
74849   return jresult;
74850 }
74851
74852
74853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
74854   int jresult ;
74855   int result;
74856
74857   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
74858   jresult = (int)result;
74859   return jresult;
74860 }
74861
74862
74863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
74864   int jresult ;
74865   int result;
74866
74867   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
74868   jresult = (int)result;
74869   return jresult;
74870 }
74871
74872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_ANIMATABLE_get() {
74873   int jresult ;
74874   int result;
74875
74876   result = (int)Dali::Toolkit::DevelTextLabel::Property::TEXT_COLOR_ANIMATABLE;
74877   jresult = (int)result;
74878   return jresult;
74879 }
74880
74881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
74882   int jresult ;
74883   int result;
74884
74885   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
74886   jresult = (int)result;
74887   return jresult;
74888 }
74889
74890
74891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
74892   int jresult ;
74893   int result;
74894
74895   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
74896   jresult = (int)result;
74897   return jresult;
74898 }
74899
74900
74901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
74902   int jresult ;
74903   int result;
74904
74905   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
74906   jresult = (int)result;
74907   return jresult;
74908 }
74909
74910
74911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
74912   int jresult ;
74913   int result;
74914
74915   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
74916   jresult = (int)result;
74917   return jresult;
74918 }
74919
74920
74921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
74922   int jresult ;
74923   int result;
74924
74925   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
74926   jresult = (int)result;
74927   return jresult;
74928 }
74929
74930
74931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
74932   int jresult ;
74933   int result;
74934
74935   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
74936   jresult = (int)result;
74937   return jresult;
74938 }
74939
74940
74941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
74942   int jresult ;
74943   int result;
74944
74945   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
74946   jresult = (int)result;
74947   return jresult;
74948 }
74949
74950
74951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
74952   int jresult ;
74953   int result;
74954
74955   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
74956   jresult = (int)result;
74957   return jresult;
74958 }
74959
74960
74961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
74962   int jresult ;
74963   int result;
74964
74965   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
74966   jresult = (int)result;
74967   return jresult;
74968 }
74969
74970
74971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
74972   int jresult ;
74973   int result;
74974
74975   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
74976   jresult = (int)result;
74977   return jresult;
74978 }
74979
74980
74981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
74982   int jresult ;
74983   int result;
74984
74985   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
74986   jresult = (int)result;
74987   return jresult;
74988 }
74989
74990
74991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
74992   int jresult ;
74993   int result;
74994
74995   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
74996   jresult = (int)result;
74997   return jresult;
74998 }
74999
75000
75001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
75002   int jresult ;
75003   int result;
75004
75005   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
75006   jresult = (int)result;
75007   return jresult;
75008 }
75009
75010
75011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
75012   int jresult ;
75013   int result;
75014
75015   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
75016   jresult = (int)result;
75017   return jresult;
75018 }
75019
75020
75021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
75022   int jresult ;
75023   int result;
75024
75025   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
75026   jresult = (int)result;
75027   return jresult;
75028 }
75029
75030
75031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
75032   void * jresult ;
75033   Dali::Toolkit::TextLabel::Property *result = 0 ;
75034
75035   {
75036     try {
75037       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
75038     } catch (std::out_of_range& e) {
75039       {
75040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75041       };
75042     } catch (std::exception& e) {
75043       {
75044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75045       };
75046     } catch (...) {
75047       {
75048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75049       };
75050     }
75051   }
75052   jresult = (void *)result;
75053   return jresult;
75054 }
75055
75056
75057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
75058   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
75059
75060   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
75061   {
75062     try {
75063       delete arg1;
75064     } catch (std::out_of_range& e) {
75065       {
75066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75067       };
75068     } catch (std::exception& e) {
75069       {
75070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75071       };
75072     } catch (...) {
75073       {
75074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75075       };
75076     }
75077   }
75078 }
75079
75080
75081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
75082   void * jresult ;
75083   Dali::Toolkit::TextLabel result;
75084
75085   {
75086     try {
75087       result = Dali::Toolkit::TextLabel::New();
75088     } catch (std::out_of_range& e) {
75089       {
75090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75091       };
75092     } catch (std::exception& e) {
75093       {
75094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75095       };
75096     } catch (...) {
75097       {
75098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75099       };
75100     }
75101   }
75102   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75103   return jresult;
75104 }
75105
75106
75107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
75108   void * jresult ;
75109   std::string *arg1 = 0 ;
75110   Dali::Toolkit::TextLabel result;
75111
75112   if (!jarg1) {
75113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75114     return 0;
75115   }
75116   std::string arg1_str(jarg1);
75117   arg1 = &arg1_str;
75118   {
75119     try {
75120       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
75121     } catch (std::out_of_range& e) {
75122       {
75123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75124       };
75125     } catch (std::exception& e) {
75126       {
75127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75128       };
75129     } catch (...) {
75130       {
75131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75132       };
75133     }
75134   }
75135   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75136
75137   //argout typemap for const std::string&
75138
75139   return jresult;
75140 }
75141
75142
75143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
75144   void * jresult ;
75145   Dali::Toolkit::TextLabel *result = 0 ;
75146
75147   {
75148     try {
75149       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
75150     } catch (std::out_of_range& e) {
75151       {
75152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75153       };
75154     } catch (std::exception& e) {
75155       {
75156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75157       };
75158     } catch (...) {
75159       {
75160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75161       };
75162     }
75163   }
75164   jresult = (void *)result;
75165   return jresult;
75166 }
75167
75168
75169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
75170   void * jresult ;
75171   Dali::Toolkit::TextLabel *arg1 = 0 ;
75172   Dali::Toolkit::TextLabel *result = 0 ;
75173
75174   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75175   if (!arg1) {
75176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75177     return 0;
75178   }
75179   {
75180     try {
75181       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
75182     } catch (std::out_of_range& e) {
75183       {
75184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75185       };
75186     } catch (std::exception& e) {
75187       {
75188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75189       };
75190     } catch (...) {
75191       {
75192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75193       };
75194     }
75195   }
75196   jresult = (void *)result;
75197   return jresult;
75198 }
75199
75200
75201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
75202   void * jresult ;
75203   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75204   Dali::Toolkit::TextLabel *arg2 = 0 ;
75205   Dali::Toolkit::TextLabel *result = 0 ;
75206
75207   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75208   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
75209   if (!arg2) {
75210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
75211     return 0;
75212   }
75213   {
75214     try {
75215       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
75216     } catch (std::out_of_range& e) {
75217       {
75218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75219       };
75220     } catch (std::exception& e) {
75221       {
75222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75227       };
75228     }
75229   }
75230   jresult = (void *)result;
75231   return jresult;
75232 }
75233
75234
75235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
75236   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
75237
75238   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
75239   {
75240     try {
75241       delete arg1;
75242     } catch (std::out_of_range& e) {
75243       {
75244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75245       };
75246     } catch (std::exception& e) {
75247       {
75248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75249       };
75250     } catch (...) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75253       };
75254     }
75255   }
75256 }
75257
75258
75259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
75260   void * jresult ;
75261   Dali::BaseHandle arg1 ;
75262   Dali::BaseHandle *argp1 ;
75263   Dali::Toolkit::TextLabel result;
75264
75265   argp1 = (Dali::BaseHandle *)jarg1;
75266   if (!argp1) {
75267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75268     return 0;
75269   }
75270   arg1 = *argp1;
75271   {
75272     try {
75273       result = Dali::Toolkit::TextLabel::DownCast(arg1);
75274     } catch (std::out_of_range& e) {
75275       {
75276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75277       };
75278     } catch (std::exception& e) {
75279       {
75280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75281       };
75282     } catch (...) {
75283       {
75284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75285       };
75286     }
75287   }
75288   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
75289   return jresult;
75290 }
75291
75292
75293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
75294   void * jresult ;
75295   Dali::Toolkit::AccessibilityManager *result = 0 ;
75296
75297   {
75298     try {
75299       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
75300     } catch (std::out_of_range& e) {
75301       {
75302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75303       };
75304     } catch (std::exception& e) {
75305       {
75306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75307       };
75308     } catch (...) {
75309       {
75310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75311       };
75312     }
75313   }
75314   jresult = (void *)result;
75315   return jresult;
75316 }
75317
75318
75319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
75320   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75321
75322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75323   {
75324     try {
75325       delete arg1;
75326     } catch (std::out_of_range& e) {
75327       {
75328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75329       };
75330     } catch (std::exception& e) {
75331       {
75332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75337       };
75338     }
75339   }
75340 }
75341
75342
75343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
75344   void * jresult ;
75345   Dali::Toolkit::AccessibilityManager result;
75346
75347   {
75348     try {
75349       result = Dali::Toolkit::AccessibilityManager::Get();
75350     } catch (std::out_of_range& e) {
75351       {
75352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75353       };
75354     } catch (std::exception& e) {
75355       {
75356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75357       };
75358     } catch (...) {
75359       {
75360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75361       };
75362     }
75363   }
75364   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
75365   return jresult;
75366 }
75367
75368
75369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
75370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75371   Dali::Actor arg2 ;
75372   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75373   std::string *arg4 = 0 ;
75374   Dali::Actor *argp2 ;
75375
75376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75377   argp2 = (Dali::Actor *)jarg2;
75378   if (!argp2) {
75379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75380     return ;
75381   }
75382   arg2 = *argp2;
75383   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75384   if (!jarg4) {
75385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
75386     return ;
75387   }
75388   std::string arg4_str(jarg4);
75389   arg4 = &arg4_str;
75390   {
75391     try {
75392       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
75393     } catch (std::out_of_range& e) {
75394       {
75395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75396       };
75397     } catch (std::exception& e) {
75398       {
75399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75400       };
75401     } catch (...) {
75402       {
75403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75404       };
75405     }
75406   }
75407
75408   //argout typemap for const std::string&
75409
75410 }
75411
75412
75413 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
75414   char * jresult ;
75415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75416   Dali::Actor arg2 ;
75417   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
75418   Dali::Actor *argp2 ;
75419   std::string result;
75420
75421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75422   argp2 = (Dali::Actor *)jarg2;
75423   if (!argp2) {
75424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75425     return 0;
75426   }
75427   arg2 = *argp2;
75428   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
75429   {
75430     try {
75431       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
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 = SWIG_csharp_string_callback((&result)->c_str());
75447   return jresult;
75448 }
75449
75450
75451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
75452   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75453   Dali::Actor arg2 ;
75454   unsigned int arg3 ;
75455   Dali::Actor *argp2 ;
75456
75457   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75458   argp2 = (Dali::Actor *)jarg2;
75459   if (!argp2) {
75460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75461     return ;
75462   }
75463   arg2 = *argp2;
75464   arg3 = (unsigned int)jarg3;
75465   {
75466     try {
75467       (arg1)->SetFocusOrder(arg2,arg3);
75468     } catch (std::out_of_range& e) {
75469       {
75470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75471       };
75472     } catch (std::exception& e) {
75473       {
75474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75475       };
75476     } catch (...) {
75477       {
75478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75479       };
75480     }
75481   }
75482 }
75483
75484
75485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
75486   unsigned int jresult ;
75487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75488   Dali::Actor arg2 ;
75489   Dali::Actor *argp2 ;
75490   unsigned int result;
75491
75492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75493   argp2 = (Dali::Actor *)jarg2;
75494   if (!argp2) {
75495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75496     return 0;
75497   }
75498   arg2 = *argp2;
75499   {
75500     try {
75501       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
75502     } catch (std::out_of_range& e) {
75503       {
75504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75505       };
75506     } catch (std::exception& e) {
75507       {
75508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75509       };
75510     } catch (...) {
75511       {
75512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75513       };
75514     }
75515   }
75516   jresult = result;
75517   return jresult;
75518 }
75519
75520
75521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
75522   unsigned int jresult ;
75523   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75524   unsigned int result;
75525
75526   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75527   {
75528     try {
75529       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
75530     } catch (std::out_of_range& e) {
75531       {
75532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75533       };
75534     } catch (std::exception& e) {
75535       {
75536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75537       };
75538     } catch (...) {
75539       {
75540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75541       };
75542     }
75543   }
75544   jresult = result;
75545   return jresult;
75546 }
75547
75548
75549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
75550   void * jresult ;
75551   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75552   unsigned int arg2 ;
75553   Dali::Actor result;
75554
75555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75556   arg2 = (unsigned int)jarg2;
75557   {
75558     try {
75559       result = (arg1)->GetActorByFocusOrder(arg2);
75560     } catch (std::out_of_range& e) {
75561       {
75562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75563       };
75564     } catch (std::exception& e) {
75565       {
75566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75567       };
75568     } catch (...) {
75569       {
75570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75571       };
75572     }
75573   }
75574   jresult = new Dali::Actor((const Dali::Actor &)result);
75575   return jresult;
75576 }
75577
75578
75579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
75580   unsigned int jresult ;
75581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75582   Dali::Actor arg2 ;
75583   Dali::Actor *argp2 ;
75584   bool result;
75585
75586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75587   argp2 = (Dali::Actor *)jarg2;
75588   if (!argp2) {
75589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75590     return 0;
75591   }
75592   arg2 = *argp2;
75593   {
75594     try {
75595       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
75596     } catch (std::out_of_range& e) {
75597       {
75598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75599       };
75600     } catch (std::exception& e) {
75601       {
75602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75603       };
75604     } catch (...) {
75605       {
75606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75607       };
75608     }
75609   }
75610   jresult = result;
75611   return jresult;
75612 }
75613
75614
75615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
75616   void * jresult ;
75617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75618   Dali::Actor result;
75619
75620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75621   {
75622     try {
75623       result = (arg1)->GetCurrentFocusActor();
75624     } catch (std::out_of_range& e) {
75625       {
75626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75627       };
75628     } catch (std::exception& e) {
75629       {
75630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75635       };
75636     }
75637   }
75638   jresult = new Dali::Actor((const Dali::Actor &)result);
75639   return jresult;
75640 }
75641
75642
75643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
75644   void * jresult ;
75645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75646   Dali::Actor result;
75647
75648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75649   {
75650     try {
75651       result = (arg1)->GetCurrentFocusGroup();
75652     } catch (std::out_of_range& e) {
75653       {
75654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75655       };
75656     } catch (std::exception& e) {
75657       {
75658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75659       };
75660     } catch (...) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75663       };
75664     }
75665   }
75666   jresult = new Dali::Actor((const Dali::Actor &)result);
75667   return jresult;
75668 }
75669
75670
75671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
75672   unsigned int jresult ;
75673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75674   unsigned int result;
75675
75676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75677   {
75678     try {
75679       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
75680     } catch (std::out_of_range& e) {
75681       {
75682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75683       };
75684     } catch (std::exception& e) {
75685       {
75686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75687       };
75688     } catch (...) {
75689       {
75690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75691       };
75692     }
75693   }
75694   jresult = result;
75695   return jresult;
75696 }
75697
75698
75699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
75700   unsigned int jresult ;
75701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75702   bool result;
75703
75704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75705   {
75706     try {
75707       result = (bool)(arg1)->MoveFocusForward();
75708     } catch (std::out_of_range& e) {
75709       {
75710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75711       };
75712     } catch (std::exception& e) {
75713       {
75714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75719       };
75720     }
75721   }
75722   jresult = result;
75723   return jresult;
75724 }
75725
75726
75727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
75728   unsigned int jresult ;
75729   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75730   bool result;
75731
75732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75733   {
75734     try {
75735       result = (bool)(arg1)->MoveFocusBackward();
75736     } catch (std::out_of_range& e) {
75737       {
75738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75739       };
75740     } catch (std::exception& e) {
75741       {
75742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75743       };
75744     } catch (...) {
75745       {
75746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75747       };
75748     }
75749   }
75750   jresult = result;
75751   return jresult;
75752 }
75753
75754
75755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
75756   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75757
75758   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75759   {
75760     try {
75761       (arg1)->ClearFocus();
75762     } catch (std::out_of_range& e) {
75763       {
75764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75765       };
75766     } catch (std::exception& e) {
75767       {
75768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75769       };
75770     } catch (...) {
75771       {
75772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75773       };
75774     }
75775   }
75776 }
75777
75778
75779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
75780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75781
75782   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75783   {
75784     try {
75785       (arg1)->Reset();
75786     } catch (std::out_of_range& e) {
75787       {
75788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75789       };
75790     } catch (std::exception& e) {
75791       {
75792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75793       };
75794     } catch (...) {
75795       {
75796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75797       };
75798     }
75799   }
75800 }
75801
75802
75803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
75804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75805   Dali::Actor arg2 ;
75806   bool arg3 ;
75807   Dali::Actor *argp2 ;
75808
75809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75810   argp2 = (Dali::Actor *)jarg2;
75811   if (!argp2) {
75812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75813     return ;
75814   }
75815   arg2 = *argp2;
75816   arg3 = jarg3 ? true : false;
75817   {
75818     try {
75819       (arg1)->SetFocusGroup(arg2,arg3);
75820     } catch (std::out_of_range& e) {
75821       {
75822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75823       };
75824     } catch (std::exception& e) {
75825       {
75826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75827       };
75828     } catch (...) {
75829       {
75830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75831       };
75832     }
75833   }
75834 }
75835
75836
75837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
75838   unsigned int jresult ;
75839   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75840   Dali::Actor arg2 ;
75841   Dali::Actor *argp2 ;
75842   bool result;
75843
75844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75845   argp2 = (Dali::Actor *)jarg2;
75846   if (!argp2) {
75847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75848     return 0;
75849   }
75850   arg2 = *argp2;
75851   {
75852     try {
75853       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
75854     } catch (std::out_of_range& e) {
75855       {
75856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75857       };
75858     } catch (std::exception& e) {
75859       {
75860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75861       };
75862     } catch (...) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75865       };
75866     }
75867   }
75868   jresult = result;
75869   return jresult;
75870 }
75871
75872
75873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
75874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75875   bool arg2 ;
75876
75877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75878   arg2 = jarg2 ? true : false;
75879   {
75880     try {
75881       (arg1)->SetGroupMode(arg2);
75882     } catch (std::out_of_range& e) {
75883       {
75884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75885       };
75886     } catch (std::exception& e) {
75887       {
75888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75889       };
75890     } catch (...) {
75891       {
75892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75893       };
75894     }
75895   }
75896 }
75897
75898
75899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
75900   unsigned int jresult ;
75901   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75902   bool result;
75903
75904   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75905   {
75906     try {
75907       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
75908     } catch (std::out_of_range& e) {
75909       {
75910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75911       };
75912     } catch (std::exception& e) {
75913       {
75914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75915       };
75916     } catch (...) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75919       };
75920     }
75921   }
75922   jresult = result;
75923   return jresult;
75924 }
75925
75926
75927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
75928   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75929   bool arg2 ;
75930
75931   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75932   arg2 = jarg2 ? true : false;
75933   {
75934     try {
75935       (arg1)->SetWrapMode(arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
75954   unsigned int jresult ;
75955   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75956   bool result;
75957
75958   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75959   {
75960     try {
75961       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
75962     } catch (std::out_of_range& e) {
75963       {
75964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75965       };
75966     } catch (std::exception& e) {
75967       {
75968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75969       };
75970     } catch (...) {
75971       {
75972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75973       };
75974     }
75975   }
75976   jresult = result;
75977   return jresult;
75978 }
75979
75980
75981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
75982   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
75983   Dali::Actor arg2 ;
75984   Dali::Actor *argp2 ;
75985
75986   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
75987   argp2 = (Dali::Actor *)jarg2;
75988   if (!argp2) {
75989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75990     return ;
75991   }
75992   arg2 = *argp2;
75993   {
75994     try {
75995       (arg1)->SetFocusIndicatorActor(arg2);
75996     } catch (std::out_of_range& e) {
75997       {
75998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75999       };
76000     } catch (std::exception& e) {
76001       {
76002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76003       };
76004     } catch (...) {
76005       {
76006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76007       };
76008     }
76009   }
76010 }
76011
76012
76013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
76014   void * jresult ;
76015   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76016   Dali::Actor result;
76017
76018   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76019   {
76020     try {
76021       result = (arg1)->GetFocusIndicatorActor();
76022     } catch (std::out_of_range& e) {
76023       {
76024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76025       };
76026     } catch (std::exception& e) {
76027       {
76028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76029       };
76030     } catch (...) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76033       };
76034     }
76035   }
76036   jresult = new Dali::Actor((const Dali::Actor &)result);
76037   return jresult;
76038 }
76039
76040
76041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
76042   void * jresult ;
76043   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76044   Dali::Actor arg2 ;
76045   Dali::Actor *argp2 ;
76046   Dali::Actor result;
76047
76048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76049   argp2 = (Dali::Actor *)jarg2;
76050   if (!argp2) {
76051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76052     return 0;
76053   }
76054   arg2 = *argp2;
76055   {
76056     try {
76057       result = (arg1)->GetFocusGroup(arg2);
76058     } catch (std::out_of_range& e) {
76059       {
76060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76061       };
76062     } catch (std::exception& e) {
76063       {
76064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76065       };
76066     } catch (...) {
76067       {
76068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76069       };
76070     }
76071   }
76072   jresult = new Dali::Actor((const Dali::Actor &)result);
76073   return jresult;
76074 }
76075
76076
76077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
76078   void * jresult ;
76079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76080   Dali::Vector2 result;
76081
76082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76083   {
76084     try {
76085       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
76086     } catch (std::out_of_range& e) {
76087       {
76088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76089       };
76090     } catch (std::exception& e) {
76091       {
76092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76093       };
76094     } catch (...) {
76095       {
76096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76097       };
76098     }
76099   }
76100   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76101   return jresult;
76102 }
76103
76104
76105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
76106   void * jresult ;
76107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76108   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
76109
76110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76111   {
76112     try {
76113       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
76114     } catch (std::out_of_range& e) {
76115       {
76116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76117       };
76118     } catch (std::exception& e) {
76119       {
76120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76121       };
76122     } catch (...) {
76123       {
76124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76125       };
76126     }
76127   }
76128   jresult = (void *)result;
76129   return jresult;
76130 }
76131
76132
76133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
76134   void * jresult ;
76135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76136   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
76137
76138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76139   {
76140     try {
76141       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
76142     } catch (std::out_of_range& e) {
76143       {
76144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76145       };
76146     } catch (std::exception& e) {
76147       {
76148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76149       };
76150     } catch (...) {
76151       {
76152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76153       };
76154     }
76155   }
76156   jresult = (void *)result;
76157   return jresult;
76158 }
76159
76160
76161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
76162   void * jresult ;
76163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76164   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
76165
76166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76167   {
76168     try {
76169       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
76170     } catch (std::out_of_range& e) {
76171       {
76172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76173       };
76174     } catch (std::exception& e) {
76175       {
76176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76177       };
76178     } catch (...) {
76179       {
76180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76181       };
76182     }
76183   }
76184   jresult = (void *)result;
76185   return jresult;
76186 }
76187
76188
76189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
76190   void * jresult ;
76191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76192   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76193
76194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76195   {
76196     try {
76197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
76198     } catch (std::out_of_range& e) {
76199       {
76200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76201       };
76202     } catch (std::exception& e) {
76203       {
76204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76205       };
76206     } catch (...) {
76207       {
76208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76209       };
76210     }
76211   }
76212   jresult = (void *)result;
76213   return jresult;
76214 }
76215
76216
76217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
76218   void * jresult ;
76219   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76220   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76221
76222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76223   {
76224     try {
76225       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
76226     } catch (std::out_of_range& e) {
76227       {
76228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76229       };
76230     } catch (std::exception& e) {
76231       {
76232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76233       };
76234     } catch (...) {
76235       {
76236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76237       };
76238     }
76239   }
76240   jresult = (void *)result;
76241   return jresult;
76242 }
76243
76244
76245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
76246   void * jresult ;
76247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76248   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76249
76250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76251   {
76252     try {
76253       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
76254     } catch (std::out_of_range& e) {
76255       {
76256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76257       };
76258     } catch (std::exception& e) {
76259       {
76260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76261       };
76262     } catch (...) {
76263       {
76264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76265       };
76266     }
76267   }
76268   jresult = (void *)result;
76269   return jresult;
76270 }
76271
76272
76273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
76274   void * jresult ;
76275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76276   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76277
76278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76279   {
76280     try {
76281       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
76282     } catch (std::out_of_range& e) {
76283       {
76284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76285       };
76286     } catch (std::exception& e) {
76287       {
76288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76289       };
76290     } catch (...) {
76291       {
76292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76293       };
76294     }
76295   }
76296   jresult = (void *)result;
76297   return jresult;
76298 }
76299
76300
76301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
76302   void * jresult ;
76303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76304   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76305
76306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76307   {
76308     try {
76309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
76310     } catch (std::out_of_range& e) {
76311       {
76312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76313       };
76314     } catch (std::exception& e) {
76315       {
76316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76317       };
76318     } catch (...) {
76319       {
76320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76321       };
76322     }
76323   }
76324   jresult = (void *)result;
76325   return jresult;
76326 }
76327
76328
76329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
76330   void * jresult ;
76331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76332   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76333
76334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76335   {
76336     try {
76337       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
76338     } catch (std::out_of_range& e) {
76339       {
76340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76341       };
76342     } catch (std::exception& e) {
76343       {
76344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76345       };
76346     } catch (...) {
76347       {
76348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76349       };
76350     }
76351   }
76352   jresult = (void *)result;
76353   return jresult;
76354 }
76355
76356
76357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
76358   void * jresult ;
76359   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76360   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76361
76362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76363   {
76364     try {
76365       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
76366     } catch (std::out_of_range& e) {
76367       {
76368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76369       };
76370     } catch (std::exception& e) {
76371       {
76372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76373       };
76374     } catch (...) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76377       };
76378     }
76379   }
76380   jresult = (void *)result;
76381   return jresult;
76382 }
76383
76384
76385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
76386   void * jresult ;
76387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76388   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76389
76390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76391   {
76392     try {
76393       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
76394     } catch (std::out_of_range& e) {
76395       {
76396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76397       };
76398     } catch (std::exception& e) {
76399       {
76400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76401       };
76402     } catch (...) {
76403       {
76404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76405       };
76406     }
76407   }
76408   jresult = (void *)result;
76409   return jresult;
76410 }
76411
76412
76413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
76414   void * jresult ;
76415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76416   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76417
76418   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76419   {
76420     try {
76421       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
76422     } catch (std::out_of_range& e) {
76423       {
76424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76425       };
76426     } catch (std::exception& e) {
76427       {
76428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76429       };
76430     } catch (...) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76433       };
76434     }
76435   }
76436   jresult = (void *)result;
76437   return jresult;
76438 }
76439
76440
76441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
76442   void * jresult ;
76443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76444   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76445
76446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76447   {
76448     try {
76449       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
76450     } catch (std::out_of_range& e) {
76451       {
76452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76453       };
76454     } catch (std::exception& e) {
76455       {
76456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76457       };
76458     } catch (...) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76461       };
76462     }
76463   }
76464   jresult = (void *)result;
76465   return jresult;
76466 }
76467
76468
76469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
76470   void * jresult ;
76471   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76472   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76473
76474   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76475   {
76476     try {
76477       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
76478     } catch (std::out_of_range& e) {
76479       {
76480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76481       };
76482     } catch (std::exception& e) {
76483       {
76484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76485       };
76486     } catch (...) {
76487       {
76488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76489       };
76490     }
76491   }
76492   jresult = (void *)result;
76493   return jresult;
76494 }
76495
76496
76497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
76498   void * jresult ;
76499   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76500   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76501
76502   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76503   {
76504     try {
76505       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
76506     } catch (std::out_of_range& e) {
76507       {
76508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76509       };
76510     } catch (std::exception& e) {
76511       {
76512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76513       };
76514     } catch (...) {
76515       {
76516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76517       };
76518     }
76519   }
76520   jresult = (void *)result;
76521   return jresult;
76522 }
76523
76524
76525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
76526   void * jresult ;
76527   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76528   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76529
76530   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76531   {
76532     try {
76533       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
76534     } catch (std::out_of_range& e) {
76535       {
76536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76537       };
76538     } catch (std::exception& e) {
76539       {
76540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76541       };
76542     } catch (...) {
76543       {
76544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76545       };
76546     }
76547   }
76548   jresult = (void *)result;
76549   return jresult;
76550 }
76551
76552
76553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
76554   void * jresult ;
76555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76556   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76557
76558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76559   {
76560     try {
76561       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
76562     } catch (std::out_of_range& e) {
76563       {
76564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76565       };
76566     } catch (std::exception& e) {
76567       {
76568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76569       };
76570     } catch (...) {
76571       {
76572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76573       };
76574     }
76575   }
76576   jresult = (void *)result;
76577   return jresult;
76578 }
76579
76580
76581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
76582   void * jresult ;
76583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76584   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76585
76586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76587   {
76588     try {
76589       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
76590     } catch (std::out_of_range& e) {
76591       {
76592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76593       };
76594     } catch (std::exception& e) {
76595       {
76596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76597       };
76598     } catch (...) {
76599       {
76600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76601       };
76602     }
76603   }
76604   jresult = (void *)result;
76605   return jresult;
76606 }
76607
76608
76609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
76610   void * jresult ;
76611   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76612   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76613
76614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76615   {
76616     try {
76617       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
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 = (void *)result;
76633   return jresult;
76634 }
76635
76636
76637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
76638   void * jresult ;
76639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76640   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76641
76642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76643   {
76644     try {
76645       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
76646     } catch (std::out_of_range& e) {
76647       {
76648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76649       };
76650     } catch (std::exception& e) {
76651       {
76652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76653       };
76654     } catch (...) {
76655       {
76656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76657       };
76658     }
76659   }
76660   jresult = (void *)result;
76661   return jresult;
76662 }
76663
76664
76665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
76666   void * jresult ;
76667   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76668   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76669
76670   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76671   {
76672     try {
76673       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
76674     } catch (std::out_of_range& e) {
76675       {
76676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76677       };
76678     } catch (std::exception& e) {
76679       {
76680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (...) {
76683       {
76684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76685       };
76686     }
76687   }
76688   jresult = (void *)result;
76689   return jresult;
76690 }
76691
76692
76693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
76694   void * jresult ;
76695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76696   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76697
76698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76699   {
76700     try {
76701       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
76702     } catch (std::out_of_range& e) {
76703       {
76704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76705       };
76706     } catch (std::exception& e) {
76707       {
76708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76709       };
76710     } catch (...) {
76711       {
76712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76713       };
76714     }
76715   }
76716   jresult = (void *)result;
76717   return jresult;
76718 }
76719
76720
76721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
76722   void * jresult ;
76723   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76724   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76725
76726   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76727   {
76728     try {
76729       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
76730     } catch (std::out_of_range& e) {
76731       {
76732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76733       };
76734     } catch (std::exception& e) {
76735       {
76736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76737       };
76738     } catch (...) {
76739       {
76740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76741       };
76742     }
76743   }
76744   jresult = (void *)result;
76745   return jresult;
76746 }
76747
76748
76749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
76750   void * jresult ;
76751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76752   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76753
76754   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76755   {
76756     try {
76757       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
76758     } catch (std::out_of_range& e) {
76759       {
76760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76761       };
76762     } catch (std::exception& e) {
76763       {
76764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76765       };
76766     } catch (...) {
76767       {
76768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76769       };
76770     }
76771   }
76772   jresult = (void *)result;
76773   return jresult;
76774 }
76775
76776
76777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
76778   void * jresult ;
76779   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76780   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76781
76782   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76783   {
76784     try {
76785       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
76786     } catch (std::out_of_range& e) {
76787       {
76788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76789       };
76790     } catch (std::exception& e) {
76791       {
76792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76793       };
76794     } catch (...) {
76795       {
76796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76797       };
76798     }
76799   }
76800   jresult = (void *)result;
76801   return jresult;
76802 }
76803
76804
76805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
76806   void * jresult ;
76807   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76808   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76809
76810   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76811   {
76812     try {
76813       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
76814     } catch (std::out_of_range& e) {
76815       {
76816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76817       };
76818     } catch (std::exception& e) {
76819       {
76820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76821       };
76822     } catch (...) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76825       };
76826     }
76827   }
76828   jresult = (void *)result;
76829   return jresult;
76830 }
76831
76832
76833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
76834   void * jresult ;
76835   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76836   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76837
76838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76839   {
76840     try {
76841       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
76842     } catch (std::out_of_range& e) {
76843       {
76844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76845       };
76846     } catch (std::exception& e) {
76847       {
76848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76849       };
76850     } catch (...) {
76851       {
76852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76853       };
76854     }
76855   }
76856   jresult = (void *)result;
76857   return jresult;
76858 }
76859
76860
76861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
76862   void * jresult ;
76863   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76864   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76865
76866   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76867   {
76868     try {
76869       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
76870     } catch (std::out_of_range& e) {
76871       {
76872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76873       };
76874     } catch (std::exception& e) {
76875       {
76876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76877       };
76878     } catch (...) {
76879       {
76880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76881       };
76882     }
76883   }
76884   jresult = (void *)result;
76885   return jresult;
76886 }
76887
76888
76889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
76890   void * jresult ;
76891   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76892   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
76893
76894   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76895   {
76896     try {
76897       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
76898     } catch (std::out_of_range& e) {
76899       {
76900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76901       };
76902     } catch (std::exception& e) {
76903       {
76904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76905       };
76906     } catch (...) {
76907       {
76908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76909       };
76910     }
76911   }
76912   jresult = (void *)result;
76913   return jresult;
76914 }
76915
76916
76917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
76918   void * jresult ;
76919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
76920   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
76921
76922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
76923   {
76924     try {
76925       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
76926     } catch (std::out_of_range& e) {
76927       {
76928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76929       };
76930     } catch (std::exception& e) {
76931       {
76932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76933       };
76934     } catch (...) {
76935       {
76936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76937       };
76938     }
76939   }
76940   jresult = (void *)result;
76941   return jresult;
76942 }
76943
76944
76945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
76946   void * jresult ;
76947   Dali::Toolkit::StyleManager *result = 0 ;
76948
76949   {
76950     try {
76951       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
76952     } catch (std::out_of_range& e) {
76953       {
76954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (std::exception& e) {
76957       {
76958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76959       };
76960     } catch (...) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76963       };
76964     }
76965   }
76966   jresult = (void *)result;
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
76972   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
76973
76974   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
76975   {
76976     try {
76977       delete arg1;
76978     } catch (std::out_of_range& e) {
76979       {
76980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76981       };
76982     } catch (std::exception& e) {
76983       {
76984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76985       };
76986     } catch (...) {
76987       {
76988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76989       };
76990     }
76991   }
76992 }
76993
76994
76995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
76996   void * jresult ;
76997   Dali::Toolkit::StyleManager result;
76998
76999   {
77000     try {
77001       result = Dali::Toolkit::StyleManager::Get();
77002     } catch (std::out_of_range& e) {
77003       {
77004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77005       };
77006     } catch (std::exception& e) {
77007       {
77008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77009       };
77010     } catch (...) {
77011       {
77012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77013       };
77014     }
77015   }
77016   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
77017   return jresult;
77018 }
77019
77020
77021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
77022   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77023   std::string *arg2 = 0 ;
77024
77025   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77026   if (!jarg2) {
77027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77028     return ;
77029   }
77030   std::string arg2_str(jarg2);
77031   arg2 = &arg2_str;
77032   {
77033     try {
77034       (arg1)->ApplyTheme((std::string const &)*arg2);
77035     } catch (std::out_of_range& e) {
77036       {
77037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77038       };
77039     } catch (std::exception& e) {
77040       {
77041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77042       };
77043     } catch (...) {
77044       {
77045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77046       };
77047     }
77048   }
77049
77050   //argout typemap for const std::string&
77051
77052 }
77053
77054
77055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
77056   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77057
77058   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77059   {
77060     try {
77061       (arg1)->ApplyDefaultTheme();
77062     } catch (std::out_of_range& e) {
77063       {
77064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77065       };
77066     } catch (std::exception& e) {
77067       {
77068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77069       };
77070     } catch (...) {
77071       {
77072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77073       };
77074     }
77075   }
77076 }
77077
77078
77079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
77080   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77081   std::string *arg2 = 0 ;
77082   Dali::Property::Value *arg3 = 0 ;
77083
77084   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77085   if (!jarg2) {
77086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77087     return ;
77088   }
77089   std::string arg2_str(jarg2);
77090   arg2 = &arg2_str;
77091   arg3 = (Dali::Property::Value *)jarg3;
77092   if (!arg3) {
77093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
77094     return ;
77095   }
77096   {
77097     try {
77098       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
77099     } catch (std::out_of_range& e) {
77100       {
77101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77102       };
77103     } catch (std::exception& e) {
77104       {
77105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77106       };
77107     } catch (...) {
77108       {
77109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77110       };
77111     }
77112   }
77113
77114   //argout typemap for const std::string&
77115
77116 }
77117
77118
77119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
77120   unsigned int jresult ;
77121   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77122   std::string *arg2 = 0 ;
77123   Dali::Property::Value *arg3 = 0 ;
77124   bool result;
77125
77126   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77127   if (!jarg2) {
77128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77129     return 0;
77130   }
77131   std::string arg2_str(jarg2);
77132   arg2 = &arg2_str;
77133   arg3 = (Dali::Property::Value *)jarg3;
77134   if (!arg3) {
77135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
77136     return 0;
77137   }
77138   {
77139     try {
77140       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
77141     } catch (std::out_of_range& e) {
77142       {
77143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77144       };
77145     } catch (std::exception& e) {
77146       {
77147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77148       };
77149     } catch (...) {
77150       {
77151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77152       };
77153     }
77154   }
77155   jresult = result;
77156
77157   //argout typemap for const std::string&
77158
77159   return jresult;
77160 }
77161
77162
77163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
77164   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77165   Dali::Toolkit::Control arg2 ;
77166   std::string *arg3 = 0 ;
77167   std::string *arg4 = 0 ;
77168   Dali::Toolkit::Control *argp2 ;
77169
77170   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77171   argp2 = (Dali::Toolkit::Control *)jarg2;
77172   if (!argp2) {
77173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
77174     return ;
77175   }
77176   arg2 = *argp2;
77177   if (!jarg3) {
77178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77179     return ;
77180   }
77181   std::string arg3_str(jarg3);
77182   arg3 = &arg3_str;
77183   if (!jarg4) {
77184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77185     return ;
77186   }
77187   std::string arg4_str(jarg4);
77188   arg4 = &arg4_str;
77189   {
77190     try {
77191       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
77192     } catch (std::out_of_range& e) {
77193       {
77194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77195       };
77196     } catch (std::exception& e) {
77197       {
77198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77199       };
77200     } catch (...) {
77201       {
77202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77203       };
77204     }
77205   }
77206
77207   //argout typemap for const std::string&
77208
77209
77210   //argout typemap for const std::string&
77211
77212 }
77213
77214
77215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
77216   void * jresult ;
77217   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
77218   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
77219
77220   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
77221   {
77222     try {
77223       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
77224     } catch (std::out_of_range& e) {
77225       {
77226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77227       };
77228     } catch (std::exception& e) {
77229       {
77230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77231       };
77232     } catch (...) {
77233       {
77234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77235       };
77236     }
77237   }
77238   jresult = (void *)result;
77239   return jresult;
77240 }
77241
77242
77243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
77244   int jresult ;
77245   int result;
77246
77247   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
77248   jresult = (int)result;
77249   return jresult;
77250 }
77251
77252
77253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
77254   int jresult ;
77255   int result;
77256
77257   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
77258   jresult = (int)result;
77259   return jresult;
77260 }
77261
77262
77263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
77264   int jresult ;
77265   int result;
77266
77267   result = (int)Dali::Toolkit::Slider::Property::VALUE;
77268   jresult = (int)result;
77269   return jresult;
77270 }
77271
77272
77273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
77274   int jresult ;
77275   int result;
77276
77277   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
77278   jresult = (int)result;
77279   return jresult;
77280 }
77281
77282
77283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
77284   int jresult ;
77285   int result;
77286
77287   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
77288   jresult = (int)result;
77289   return jresult;
77290 }
77291
77292
77293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
77294   int jresult ;
77295   int result;
77296
77297   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
77298   jresult = (int)result;
77299   return jresult;
77300 }
77301
77302
77303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
77304   int jresult ;
77305   int result;
77306
77307   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
77308   jresult = (int)result;
77309   return jresult;
77310 }
77311
77312
77313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
77314   int jresult ;
77315   int result;
77316
77317   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
77318   jresult = (int)result;
77319   return jresult;
77320 }
77321
77322
77323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
77324   int jresult ;
77325   int result;
77326
77327   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
77328   jresult = (int)result;
77329   return jresult;
77330 }
77331
77332
77333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
77334   int jresult ;
77335   int result;
77336
77337   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
77338   jresult = (int)result;
77339   return jresult;
77340 }
77341
77342
77343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
77344   int jresult ;
77345   int result;
77346
77347   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
77348   jresult = (int)result;
77349   return jresult;
77350 }
77351
77352
77353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
77354   int jresult ;
77355   int result;
77356
77357   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
77358   jresult = (int)result;
77359   return jresult;
77360 }
77361
77362
77363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
77364   int jresult ;
77365   int result;
77366
77367   result = (int)Dali::Toolkit::Slider::Property::MARKS;
77368   jresult = (int)result;
77369   return jresult;
77370 }
77371
77372
77373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
77374   int jresult ;
77375   int result;
77376
77377   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
77378   jresult = (int)result;
77379   return jresult;
77380 }
77381
77382
77383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
77384   int jresult ;
77385   int result;
77386
77387   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
77388   jresult = (int)result;
77389   return jresult;
77390 }
77391
77392
77393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
77394   void * jresult ;
77395   Dali::Toolkit::Slider::Property *result = 0 ;
77396
77397   {
77398     try {
77399       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
77400     } catch (std::out_of_range& e) {
77401       {
77402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77403       };
77404     } catch (std::exception& e) {
77405       {
77406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77407       };
77408     } catch (...) {
77409       {
77410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77411       };
77412     }
77413   }
77414   jresult = (void *)result;
77415   return jresult;
77416 }
77417
77418
77419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
77420   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
77421
77422   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
77423   {
77424     try {
77425       delete arg1;
77426     } catch (std::out_of_range& e) {
77427       {
77428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77429       };
77430     } catch (std::exception& e) {
77431       {
77432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77433       };
77434     } catch (...) {
77435       {
77436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77437       };
77438     }
77439   }
77440 }
77441
77442
77443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
77444   void * jresult ;
77445   Dali::Toolkit::Slider result;
77446
77447   {
77448     try {
77449       result = Dali::Toolkit::Slider::New();
77450     } catch (std::out_of_range& e) {
77451       {
77452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77453       };
77454     } catch (std::exception& e) {
77455       {
77456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77457       };
77458     } catch (...) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77461       };
77462     }
77463   }
77464   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77465   return jresult;
77466 }
77467
77468
77469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
77470   void * jresult ;
77471   Dali::Toolkit::Slider *result = 0 ;
77472
77473   {
77474     try {
77475       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
77476     } catch (std::out_of_range& e) {
77477       {
77478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77479       };
77480     } catch (std::exception& e) {
77481       {
77482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77483       };
77484     } catch (...) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77487       };
77488     }
77489   }
77490   jresult = (void *)result;
77491   return jresult;
77492 }
77493
77494
77495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
77496   void * jresult ;
77497   Dali::Toolkit::Slider *arg1 = 0 ;
77498   Dali::Toolkit::Slider *result = 0 ;
77499
77500   arg1 = (Dali::Toolkit::Slider *)jarg1;
77501   if (!arg1) {
77502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77503     return 0;
77504   }
77505   {
77506     try {
77507       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
77508     } catch (std::out_of_range& e) {
77509       {
77510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77511       };
77512     } catch (std::exception& e) {
77513       {
77514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77515       };
77516     } catch (...) {
77517       {
77518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77519       };
77520     }
77521   }
77522   jresult = (void *)result;
77523   return jresult;
77524 }
77525
77526
77527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
77528   void * jresult ;
77529   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77530   Dali::Toolkit::Slider *arg2 = 0 ;
77531   Dali::Toolkit::Slider *result = 0 ;
77532
77533   arg1 = (Dali::Toolkit::Slider *)jarg1;
77534   arg2 = (Dali::Toolkit::Slider *)jarg2;
77535   if (!arg2) {
77536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
77537     return 0;
77538   }
77539   {
77540     try {
77541       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
77542     } catch (std::out_of_range& e) {
77543       {
77544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77545       };
77546     } catch (std::exception& e) {
77547       {
77548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77549       };
77550     } catch (...) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77553       };
77554     }
77555   }
77556   jresult = (void *)result;
77557   return jresult;
77558 }
77559
77560
77561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
77562   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77563
77564   arg1 = (Dali::Toolkit::Slider *)jarg1;
77565   {
77566     try {
77567       delete arg1;
77568     } catch (std::out_of_range& e) {
77569       {
77570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77571       };
77572     } catch (std::exception& e) {
77573       {
77574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77579       };
77580     }
77581   }
77582 }
77583
77584
77585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
77586   void * jresult ;
77587   Dali::BaseHandle arg1 ;
77588   Dali::BaseHandle *argp1 ;
77589   Dali::Toolkit::Slider result;
77590
77591   argp1 = (Dali::BaseHandle *)jarg1;
77592   if (!argp1) {
77593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77594     return 0;
77595   }
77596   arg1 = *argp1;
77597   {
77598     try {
77599       result = Dali::Toolkit::Slider::DownCast(arg1);
77600     } catch (std::out_of_range& e) {
77601       {
77602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77603       };
77604     } catch (std::exception& e) {
77605       {
77606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77607       };
77608     } catch (...) {
77609       {
77610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77611       };
77612     }
77613   }
77614   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
77615   return jresult;
77616 }
77617
77618
77619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
77620   void * jresult ;
77621   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77622   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77623
77624   arg1 = (Dali::Toolkit::Slider *)jarg1;
77625   {
77626     try {
77627       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
77628     } catch (std::out_of_range& e) {
77629       {
77630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77631       };
77632     } catch (std::exception& e) {
77633       {
77634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77635       };
77636     } catch (...) {
77637       {
77638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77639       };
77640     }
77641   }
77642   jresult = (void *)result;
77643   return jresult;
77644 }
77645
77646
77647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
77648   void * jresult ;
77649   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77650   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
77651
77652   arg1 = (Dali::Toolkit::Slider *)jarg1;
77653   {
77654     try {
77655       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
77656     } catch (std::out_of_range& e) {
77657       {
77658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77659       };
77660     } catch (std::exception& e) {
77661       {
77662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77663       };
77664     } catch (...) {
77665       {
77666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77667       };
77668     }
77669   }
77670   jresult = (void *)result;
77671   return jresult;
77672 }
77673
77674
77675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
77676   void * jresult ;
77677   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
77678   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
77679
77680   arg1 = (Dali::Toolkit::Slider *)jarg1;
77681   {
77682     try {
77683       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
77684     } catch (std::out_of_range& e) {
77685       {
77686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77687       };
77688     } catch (std::exception& e) {
77689       {
77690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77691       };
77692     } catch (...) {
77693       {
77694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77695       };
77696     }
77697   }
77698   jresult = (void *)result;
77699   return jresult;
77700 }
77701
77702
77703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
77704   int jresult ;
77705   int result;
77706
77707   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
77708   jresult = (int)result;
77709   return jresult;
77710 }
77711
77712
77713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
77714   int jresult ;
77715   int result;
77716
77717   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
77718   jresult = (int)result;
77719   return jresult;
77720 }
77721
77722
77723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
77724   int jresult ;
77725   int result;
77726
77727   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
77728   jresult = (int)result;
77729   return jresult;
77730 }
77731
77732
77733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
77734   int jresult ;
77735   int result;
77736
77737   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
77738   jresult = (int)result;
77739   return jresult;
77740 }
77741
77742
77743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
77744   void * jresult ;
77745   Dali::Toolkit::VideoView::Property *result = 0 ;
77746
77747   {
77748     try {
77749       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
77750     } catch (std::out_of_range& e) {
77751       {
77752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77753       };
77754     } catch (std::exception& e) {
77755       {
77756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77757       };
77758     } catch (...) {
77759       {
77760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77761       };
77762     }
77763   }
77764   jresult = (void *)result;
77765   return jresult;
77766 }
77767
77768
77769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
77770   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
77771
77772   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
77773   {
77774     try {
77775       delete arg1;
77776     } catch (std::out_of_range& e) {
77777       {
77778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77779       };
77780     } catch (std::exception& e) {
77781       {
77782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77783       };
77784     } catch (...) {
77785       {
77786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77787       };
77788     }
77789   }
77790 }
77791
77792
77793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
77794   void * jresult ;
77795   Dali::Toolkit::VideoView result;
77796
77797   {
77798     try {
77799       result = Dali::Toolkit::VideoView::New();
77800     } catch (std::out_of_range& e) {
77801       {
77802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77803       };
77804     } catch (std::exception& e) {
77805       {
77806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77807       };
77808     } catch (...) {
77809       {
77810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77811       };
77812     }
77813   }
77814   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77815   return jresult;
77816 }
77817
77818
77819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
77820   void * jresult ;
77821   std::string *arg1 = 0 ;
77822   Dali::Toolkit::VideoView result;
77823
77824   if (!jarg1) {
77825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
77826     return 0;
77827   }
77828   std::string arg1_str(jarg1);
77829   arg1 = &arg1_str;
77830   {
77831     try {
77832       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
77833     } catch (std::out_of_range& e) {
77834       {
77835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77836       };
77837     } catch (std::exception& e) {
77838       {
77839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77840       };
77841     } catch (...) {
77842       {
77843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77844       };
77845     }
77846   }
77847   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
77848
77849   //argout typemap for const std::string&
77850
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
77856   void * jresult ;
77857   Dali::Toolkit::VideoView *result = 0 ;
77858
77859   {
77860     try {
77861       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
77862     } catch (std::out_of_range& e) {
77863       {
77864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77865       };
77866     } catch (std::exception& e) {
77867       {
77868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77869       };
77870     } catch (...) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77873       };
77874     }
77875   }
77876   jresult = (void *)result;
77877   return jresult;
77878 }
77879
77880
77881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
77882   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77883
77884   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77885   {
77886     try {
77887       delete arg1;
77888     } catch (std::out_of_range& e) {
77889       {
77890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77891       };
77892     } catch (std::exception& e) {
77893       {
77894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77895       };
77896     } catch (...) {
77897       {
77898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77899       };
77900     }
77901   }
77902 }
77903
77904
77905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
77906   void * jresult ;
77907   Dali::Toolkit::VideoView *arg1 = 0 ;
77908   Dali::Toolkit::VideoView *result = 0 ;
77909
77910   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77911   if (!arg1) {
77912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77913     return 0;
77914   }
77915   {
77916     try {
77917       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
77918     } catch (std::out_of_range& e) {
77919       {
77920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77921       };
77922     } catch (std::exception& e) {
77923       {
77924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77925       };
77926     } catch (...) {
77927       {
77928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77929       };
77930     }
77931   }
77932   jresult = (void *)result;
77933   return jresult;
77934 }
77935
77936
77937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
77938   void * jresult ;
77939   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
77940   Dali::Toolkit::VideoView *arg2 = 0 ;
77941   Dali::Toolkit::VideoView *result = 0 ;
77942
77943   arg1 = (Dali::Toolkit::VideoView *)jarg1;
77944   arg2 = (Dali::Toolkit::VideoView *)jarg2;
77945   if (!arg2) {
77946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
77947     return 0;
77948   }
77949   {
77950     try {
77951       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
77952     } catch (std::out_of_range& e) {
77953       {
77954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77955       };
77956     } catch (std::exception& e) {
77957       {
77958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77959       };
77960     } catch (...) {
77961       {
77962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77963       };
77964     }
77965   }
77966   jresult = (void *)result;
77967   return jresult;
77968 }
77969
77970
77971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
77972   void * jresult ;
77973   Dali::BaseHandle arg1 ;
77974   Dali::BaseHandle *argp1 ;
77975   Dali::Toolkit::VideoView result;
77976
77977   argp1 = (Dali::BaseHandle *)jarg1;
77978   if (!argp1) {
77979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77980     return 0;
77981   }
77982   arg1 = *argp1;
77983   {
77984     try {
77985       result = Dali::Toolkit::VideoView::DownCast(arg1);
77986     } catch (std::out_of_range& e) {
77987       {
77988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77989       };
77990     } catch (std::exception& e) {
77991       {
77992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (...) {
77995       {
77996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77997       };
77998     }
77999   }
78000   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
78001   return jresult;
78002 }
78003
78004
78005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
78006   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78007
78008   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78009   {
78010     try {
78011       (arg1)->Play();
78012     } catch (std::out_of_range& e) {
78013       {
78014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78015       };
78016     } catch (std::exception& e) {
78017       {
78018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78019       };
78020     } catch (...) {
78021       {
78022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78023       };
78024     }
78025   }
78026 }
78027
78028
78029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
78030   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78031
78032   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78033   {
78034     try {
78035       (arg1)->Pause();
78036     } catch (std::out_of_range& e) {
78037       {
78038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78039       };
78040     } catch (std::exception& e) {
78041       {
78042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78043       };
78044     } catch (...) {
78045       {
78046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78047       };
78048     }
78049   }
78050 }
78051
78052
78053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
78054   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78055
78056   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78057   {
78058     try {
78059       (arg1)->Stop();
78060     } catch (std::out_of_range& e) {
78061       {
78062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78063       };
78064     } catch (std::exception& e) {
78065       {
78066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78067       };
78068     } catch (...) {
78069       {
78070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78071       };
78072     }
78073   }
78074 }
78075
78076
78077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
78078   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78079   int arg2 ;
78080
78081   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78082   arg2 = (int)jarg2;
78083   {
78084     try {
78085       (arg1)->Forward(arg2);
78086     } catch (std::out_of_range& e) {
78087       {
78088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78089       };
78090     } catch (std::exception& e) {
78091       {
78092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78093       };
78094     } catch (...) {
78095       {
78096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78097       };
78098     }
78099   }
78100 }
78101
78102
78103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
78104   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78105   int arg2 ;
78106
78107   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78108   arg2 = (int)jarg2;
78109   {
78110     try {
78111       (arg1)->Backward(arg2);
78112     } catch (std::out_of_range& e) {
78113       {
78114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78115       };
78116     } catch (std::exception& e) {
78117       {
78118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78119       };
78120     } catch (...) {
78121       {
78122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78123       };
78124     }
78125   }
78126 }
78127
78128
78129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
78130   void * jresult ;
78131   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
78132   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
78133
78134   arg1 = (Dali::Toolkit::VideoView *)jarg1;
78135   {
78136     try {
78137       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
78138     } catch (std::out_of_range& e) {
78139       {
78140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78141       };
78142     } catch (std::exception& e) {
78143       {
78144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78145       };
78146     } catch (...) {
78147       {
78148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78149       };
78150     }
78151   }
78152   jresult = (void *)result;
78153   return jresult;
78154 }
78155
78156
78157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
78158   int jresult ;
78159   int result;
78160
78161   result = (int)Dali::Toolkit::Popup::Property::TITLE;
78162   jresult = (int)result;
78163   return jresult;
78164 }
78165
78166
78167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
78168   int jresult ;
78169   int result;
78170
78171   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
78172   jresult = (int)result;
78173   return jresult;
78174 }
78175
78176
78177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
78178   int jresult ;
78179   int result;
78180
78181   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
78182   jresult = (int)result;
78183   return jresult;
78184 }
78185
78186
78187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
78188   int jresult ;
78189   int result;
78190
78191   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
78192   jresult = (int)result;
78193   return jresult;
78194 }
78195
78196
78197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
78198   int jresult ;
78199   int result;
78200
78201   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
78202   jresult = (int)result;
78203   return jresult;
78204 }
78205
78206
78207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
78208   int jresult ;
78209   int result;
78210
78211   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
78212   jresult = (int)result;
78213   return jresult;
78214 }
78215
78216
78217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
78218   int jresult ;
78219   int result;
78220
78221   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
78222   jresult = (int)result;
78223   return jresult;
78224 }
78225
78226
78227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
78228   int jresult ;
78229   int result;
78230
78231   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
78232   jresult = (int)result;
78233   return jresult;
78234 }
78235
78236
78237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
78238   int jresult ;
78239   int result;
78240
78241   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
78242   jresult = (int)result;
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
78248   int jresult ;
78249   int result;
78250
78251   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
78252   jresult = (int)result;
78253   return jresult;
78254 }
78255
78256
78257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
78258   int jresult ;
78259   int result;
78260
78261   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
78262   jresult = (int)result;
78263   return jresult;
78264 }
78265
78266
78267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
78268   int jresult ;
78269   int result;
78270
78271   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
78272   jresult = (int)result;
78273   return jresult;
78274 }
78275
78276
78277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
78278   int jresult ;
78279   int result;
78280
78281   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
78282   jresult = (int)result;
78283   return jresult;
78284 }
78285
78286
78287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
78288   int jresult ;
78289   int result;
78290
78291   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
78292   jresult = (int)result;
78293   return jresult;
78294 }
78295
78296
78297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
78298   int jresult ;
78299   int result;
78300
78301   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
78302   jresult = (int)result;
78303   return jresult;
78304 }
78305
78306
78307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
78308   int jresult ;
78309   int result;
78310
78311   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
78312   jresult = (int)result;
78313   return jresult;
78314 }
78315
78316
78317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
78318   int jresult ;
78319   int result;
78320
78321   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
78322   jresult = (int)result;
78323   return jresult;
78324 }
78325
78326
78327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
78328   int jresult ;
78329   int result;
78330
78331   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
78332   jresult = (int)result;
78333   return jresult;
78334 }
78335
78336
78337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
78338   int jresult ;
78339   int result;
78340
78341   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
78342   jresult = (int)result;
78343   return jresult;
78344 }
78345
78346
78347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
78348   int jresult ;
78349   int result;
78350
78351   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
78352   jresult = (int)result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
78358   int jresult ;
78359   int result;
78360
78361   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
78362   jresult = (int)result;
78363   return jresult;
78364 }
78365
78366
78367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
78368   void * jresult ;
78369   Dali::Toolkit::Popup::Property *result = 0 ;
78370
78371   {
78372     try {
78373       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
78374     } catch (std::out_of_range& e) {
78375       {
78376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78377       };
78378     } catch (std::exception& e) {
78379       {
78380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78381       };
78382     } catch (...) {
78383       {
78384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78385       };
78386     }
78387   }
78388   jresult = (void *)result;
78389   return jresult;
78390 }
78391
78392
78393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
78394   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
78395
78396   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
78397   {
78398     try {
78399       delete arg1;
78400     } catch (std::out_of_range& e) {
78401       {
78402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78403       };
78404     } catch (std::exception& e) {
78405       {
78406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78407       };
78408     } catch (...) {
78409       {
78410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78411       };
78412     }
78413   }
78414 }
78415
78416
78417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
78418   void * jresult ;
78419   Dali::Toolkit::Popup *result = 0 ;
78420
78421   {
78422     try {
78423       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
78424     } catch (std::out_of_range& e) {
78425       {
78426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78427       };
78428     } catch (std::exception& e) {
78429       {
78430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78431       };
78432     } catch (...) {
78433       {
78434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78435       };
78436     }
78437   }
78438   jresult = (void *)result;
78439   return jresult;
78440 }
78441
78442
78443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
78444   void * jresult ;
78445   Dali::Toolkit::Popup result;
78446
78447   {
78448     try {
78449       result = Dali::Toolkit::Popup::New();
78450     } catch (std::out_of_range& e) {
78451       {
78452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78453       };
78454     } catch (std::exception& e) {
78455       {
78456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78457       };
78458     } catch (...) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78461       };
78462     }
78463   }
78464   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
78470   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78471
78472   arg1 = (Dali::Toolkit::Popup *)jarg1;
78473   {
78474     try {
78475       delete arg1;
78476     } catch (std::out_of_range& e) {
78477       {
78478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78479       };
78480     } catch (std::exception& e) {
78481       {
78482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78483       };
78484     } catch (...) {
78485       {
78486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78487       };
78488     }
78489   }
78490 }
78491
78492
78493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
78494   void * jresult ;
78495   Dali::Toolkit::Popup *arg1 = 0 ;
78496   Dali::Toolkit::Popup *result = 0 ;
78497
78498   arg1 = (Dali::Toolkit::Popup *)jarg1;
78499   if (!arg1) {
78500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78501     return 0;
78502   }
78503   {
78504     try {
78505       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
78506     } catch (std::out_of_range& e) {
78507       {
78508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78509       };
78510     } catch (std::exception& e) {
78511       {
78512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78513       };
78514     } catch (...) {
78515       {
78516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78517       };
78518     }
78519   }
78520   jresult = (void *)result;
78521   return jresult;
78522 }
78523
78524
78525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
78526   void * jresult ;
78527   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78528   Dali::Toolkit::Popup *arg2 = 0 ;
78529   Dali::Toolkit::Popup *result = 0 ;
78530
78531   arg1 = (Dali::Toolkit::Popup *)jarg1;
78532   arg2 = (Dali::Toolkit::Popup *)jarg2;
78533   if (!arg2) {
78534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
78535     return 0;
78536   }
78537   {
78538     try {
78539       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
78540     } catch (std::out_of_range& e) {
78541       {
78542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78543       };
78544     } catch (std::exception& e) {
78545       {
78546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78547       };
78548     } catch (...) {
78549       {
78550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78551       };
78552     }
78553   }
78554   jresult = (void *)result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
78560   void * jresult ;
78561   Dali::BaseHandle arg1 ;
78562   Dali::BaseHandle *argp1 ;
78563   Dali::Toolkit::Popup result;
78564
78565   argp1 = (Dali::BaseHandle *)jarg1;
78566   if (!argp1) {
78567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78568     return 0;
78569   }
78570   arg1 = *argp1;
78571   {
78572     try {
78573       result = Dali::Toolkit::Popup::DownCast(arg1);
78574     } catch (std::out_of_range& e) {
78575       {
78576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78577       };
78578     } catch (std::exception& e) {
78579       {
78580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78581       };
78582     } catch (...) {
78583       {
78584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78585       };
78586     }
78587   }
78588   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
78589   return jresult;
78590 }
78591
78592
78593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
78594   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78595   Dali::Actor arg2 ;
78596   Dali::Actor *argp2 ;
78597
78598   arg1 = (Dali::Toolkit::Popup *)jarg1;
78599   argp2 = (Dali::Actor *)jarg2;
78600   if (!argp2) {
78601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78602     return ;
78603   }
78604   arg2 = *argp2;
78605   {
78606     try {
78607       (arg1)->SetTitle(arg2);
78608     } catch (std::out_of_range& e) {
78609       {
78610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78611       };
78612     } catch (std::exception& e) {
78613       {
78614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78615       };
78616     } catch (...) {
78617       {
78618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78619       };
78620     }
78621   }
78622 }
78623
78624
78625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
78626   void * jresult ;
78627   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78628   Dali::Actor result;
78629
78630   arg1 = (Dali::Toolkit::Popup *)jarg1;
78631   {
78632     try {
78633       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
78634     } catch (std::out_of_range& e) {
78635       {
78636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78637       };
78638     } catch (std::exception& e) {
78639       {
78640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78641       };
78642     } catch (...) {
78643       {
78644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78645       };
78646     }
78647   }
78648   jresult = new Dali::Actor((const Dali::Actor &)result);
78649   return jresult;
78650 }
78651
78652
78653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
78654   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78655   Dali::Actor arg2 ;
78656   Dali::Actor *argp2 ;
78657
78658   arg1 = (Dali::Toolkit::Popup *)jarg1;
78659   argp2 = (Dali::Actor *)jarg2;
78660   if (!argp2) {
78661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78662     return ;
78663   }
78664   arg2 = *argp2;
78665   {
78666     try {
78667       (arg1)->SetContent(arg2);
78668     } catch (std::out_of_range& e) {
78669       {
78670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78671       };
78672     } catch (std::exception& e) {
78673       {
78674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78675       };
78676     } catch (...) {
78677       {
78678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78679       };
78680     }
78681   }
78682 }
78683
78684
78685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
78686   void * jresult ;
78687   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78688   Dali::Actor result;
78689
78690   arg1 = (Dali::Toolkit::Popup *)jarg1;
78691   {
78692     try {
78693       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
78694     } catch (std::out_of_range& e) {
78695       {
78696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78697       };
78698     } catch (std::exception& e) {
78699       {
78700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78701       };
78702     } catch (...) {
78703       {
78704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78705       };
78706     }
78707   }
78708   jresult = new Dali::Actor((const Dali::Actor &)result);
78709   return jresult;
78710 }
78711
78712
78713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
78714   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78715   Dali::Actor arg2 ;
78716   Dali::Actor *argp2 ;
78717
78718   arg1 = (Dali::Toolkit::Popup *)jarg1;
78719   argp2 = (Dali::Actor *)jarg2;
78720   if (!argp2) {
78721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78722     return ;
78723   }
78724   arg2 = *argp2;
78725   {
78726     try {
78727       (arg1)->SetFooter(arg2);
78728     } catch (std::out_of_range& e) {
78729       {
78730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78731       };
78732     } catch (std::exception& e) {
78733       {
78734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78735       };
78736     } catch (...) {
78737       {
78738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78739       };
78740     }
78741   }
78742 }
78743
78744
78745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
78746   void * jresult ;
78747   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78748   Dali::Actor result;
78749
78750   arg1 = (Dali::Toolkit::Popup *)jarg1;
78751   {
78752     try {
78753       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
78754     } catch (std::out_of_range& e) {
78755       {
78756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (std::exception& e) {
78759       {
78760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (...) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78765       };
78766     }
78767   }
78768   jresult = new Dali::Actor((const Dali::Actor &)result);
78769   return jresult;
78770 }
78771
78772
78773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
78774   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78775   Dali::Toolkit::Popup::DisplayState arg2 ;
78776
78777   arg1 = (Dali::Toolkit::Popup *)jarg1;
78778   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
78779   {
78780     try {
78781       (arg1)->SetDisplayState(arg2);
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 int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
78800   int jresult ;
78801   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78802   Dali::Toolkit::Popup::DisplayState result;
78803
78804   arg1 = (Dali::Toolkit::Popup *)jarg1;
78805   {
78806     try {
78807       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
78808     } catch (std::out_of_range& e) {
78809       {
78810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (std::exception& e) {
78813       {
78814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822   jresult = (int)result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
78828   void * jresult ;
78829   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78830   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
78831
78832   arg1 = (Dali::Toolkit::Popup *)jarg1;
78833   {
78834     try {
78835       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
78836     } catch (std::out_of_range& e) {
78837       {
78838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78839       };
78840     } catch (std::exception& e) {
78841       {
78842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78843       };
78844     } catch (...) {
78845       {
78846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78847       };
78848     }
78849   }
78850   jresult = (void *)result;
78851   return jresult;
78852 }
78853
78854
78855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
78856   void * jresult ;
78857   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78858   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78859
78860   arg1 = (Dali::Toolkit::Popup *)jarg1;
78861   {
78862     try {
78863       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
78864     } catch (std::out_of_range& e) {
78865       {
78866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78867       };
78868     } catch (std::exception& e) {
78869       {
78870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78871       };
78872     } catch (...) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78875       };
78876     }
78877   }
78878   jresult = (void *)result;
78879   return jresult;
78880 }
78881
78882
78883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
78884   void * jresult ;
78885   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78886   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78887
78888   arg1 = (Dali::Toolkit::Popup *)jarg1;
78889   {
78890     try {
78891       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
78892     } catch (std::out_of_range& e) {
78893       {
78894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78895       };
78896     } catch (std::exception& e) {
78897       {
78898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78899       };
78900     } catch (...) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78903       };
78904     }
78905   }
78906   jresult = (void *)result;
78907   return jresult;
78908 }
78909
78910
78911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
78912   void * jresult ;
78913   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78914   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78915
78916   arg1 = (Dali::Toolkit::Popup *)jarg1;
78917   {
78918     try {
78919       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
78920     } catch (std::out_of_range& e) {
78921       {
78922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78923       };
78924     } catch (std::exception& e) {
78925       {
78926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78927       };
78928     } catch (...) {
78929       {
78930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78931       };
78932     }
78933   }
78934   jresult = (void *)result;
78935   return jresult;
78936 }
78937
78938
78939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
78940   void * jresult ;
78941   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
78942   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
78943
78944   arg1 = (Dali::Toolkit::Popup *)jarg1;
78945   {
78946     try {
78947       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
78948     } catch (std::out_of_range& e) {
78949       {
78950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78951       };
78952     } catch (std::exception& e) {
78953       {
78954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78955       };
78956     } catch (...) {
78957       {
78958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78959       };
78960     }
78961   }
78962   jresult = (void *)result;
78963   return jresult;
78964 }
78965
78966
78967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
78968   int jresult ;
78969   int result;
78970
78971   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
78972   jresult = (int)result;
78973   return jresult;
78974 }
78975
78976
78977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
78978   int jresult ;
78979   int result;
78980
78981   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
78982   jresult = (int)result;
78983   return jresult;
78984 }
78985
78986
78987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
78988   int jresult ;
78989   int result;
78990
78991   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
78992   jresult = (int)result;
78993   return jresult;
78994 }
78995
78996
78997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
78998   int jresult ;
78999   int result;
79000
79001   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
79002   jresult = (int)result;
79003   return jresult;
79004 }
79005
79006
79007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
79008   int jresult ;
79009   int result;
79010
79011   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
79012   jresult = (int)result;
79013   return jresult;
79014 }
79015
79016
79017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
79018   int jresult ;
79019   int result;
79020
79021   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
79022   jresult = (int)result;
79023   return jresult;
79024 }
79025
79026
79027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
79028   int jresult ;
79029   int result;
79030
79031   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
79032   jresult = (int)result;
79033   return jresult;
79034 }
79035
79036
79037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
79038   int jresult ;
79039   int result;
79040
79041   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
79042   jresult = (int)result;
79043   return jresult;
79044 }
79045
79046
79047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
79048   int jresult ;
79049   int result;
79050
79051   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
79052   jresult = (int)result;
79053   return jresult;
79054 }
79055
79056
79057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
79058   void * jresult ;
79059   Dali::Toolkit::ProgressBar::Property *result = 0 ;
79060
79061   {
79062     try {
79063       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
79064     } catch (std::out_of_range& e) {
79065       {
79066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79067       };
79068     } catch (std::exception& e) {
79069       {
79070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79071       };
79072     } catch (...) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79075       };
79076     }
79077   }
79078   jresult = (void *)result;
79079   return jresult;
79080 }
79081
79082
79083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
79084   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
79085
79086   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
79087   {
79088     try {
79089       delete arg1;
79090     } catch (std::out_of_range& e) {
79091       {
79092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79093       };
79094     } catch (std::exception& e) {
79095       {
79096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79097       };
79098     } catch (...) {
79099       {
79100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79101       };
79102     }
79103   }
79104 }
79105
79106
79107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
79108   void * jresult ;
79109   Dali::Toolkit::ProgressBar result;
79110
79111   {
79112     try {
79113       result = Dali::Toolkit::ProgressBar::New();
79114     } catch (std::out_of_range& e) {
79115       {
79116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79117       };
79118     } catch (std::exception& e) {
79119       {
79120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79121       };
79122     } catch (...) {
79123       {
79124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79125       };
79126     }
79127   }
79128   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
79129   return jresult;
79130 }
79131
79132
79133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
79134   void * jresult ;
79135   Dali::Toolkit::ProgressBar *result = 0 ;
79136
79137   {
79138     try {
79139       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
79140     } catch (std::out_of_range& e) {
79141       {
79142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (std::exception& e) {
79145       {
79146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (...) {
79149       {
79150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79151       };
79152     }
79153   }
79154   jresult = (void *)result;
79155   return jresult;
79156 }
79157
79158
79159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
79160   void * jresult ;
79161   Dali::Toolkit::ProgressBar *arg1 = 0 ;
79162   Dali::Toolkit::ProgressBar *result = 0 ;
79163
79164   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79165   if (!arg1) {
79166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79167     return 0;
79168   }
79169   {
79170     try {
79171       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
79172     } catch (std::out_of_range& e) {
79173       {
79174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79175       };
79176     } catch (std::exception& e) {
79177       {
79178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (...) {
79181       {
79182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79183       };
79184     }
79185   }
79186   jresult = (void *)result;
79187   return jresult;
79188 }
79189
79190
79191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
79192   void * jresult ;
79193   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79194   Dali::Toolkit::ProgressBar *arg2 = 0 ;
79195   Dali::Toolkit::ProgressBar *result = 0 ;
79196
79197   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79198   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
79199   if (!arg2) {
79200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
79201     return 0;
79202   }
79203   {
79204     try {
79205       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
79206     } catch (std::out_of_range& e) {
79207       {
79208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79209       };
79210     } catch (std::exception& e) {
79211       {
79212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79213       };
79214     } catch (...) {
79215       {
79216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79217       };
79218     }
79219   }
79220   jresult = (void *)result;
79221   return jresult;
79222 }
79223
79224
79225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
79226   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79227
79228   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79229   {
79230     try {
79231       delete arg1;
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_ProgressBar_DownCast(void * jarg1) {
79250   void * jresult ;
79251   Dali::BaseHandle arg1 ;
79252   Dali::BaseHandle *argp1 ;
79253   Dali::Toolkit::ProgressBar result;
79254
79255   argp1 = (Dali::BaseHandle *)jarg1;
79256   if (!argp1) {
79257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79258     return 0;
79259   }
79260   arg1 = *argp1;
79261   {
79262     try {
79263       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
79264     } catch (std::out_of_range& e) {
79265       {
79266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79267       };
79268     } catch (std::exception& e) {
79269       {
79270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79271       };
79272     } catch (...) {
79273       {
79274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79275       };
79276     }
79277   }
79278   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
79279   return jresult;
79280 }
79281
79282
79283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
79284   void * jresult ;
79285   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
79286   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
79287
79288   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
79289   {
79290     try {
79291       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
79292     } catch (std::out_of_range& e) {
79293       {
79294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79295       };
79296     } catch (std::exception& e) {
79297       {
79298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79299       };
79300     } catch (...) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79303       };
79304     }
79305   }
79306   jresult = (void *)result;
79307   return jresult;
79308 }
79309
79310
79311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
79312   void * jresult ;
79313   Dali::Toolkit::GaussianBlurView *result = 0 ;
79314
79315   {
79316     try {
79317       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
79318     } catch (std::out_of_range& e) {
79319       {
79320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79321       };
79322     } catch (std::exception& e) {
79323       {
79324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79325       };
79326     } catch (...) {
79327       {
79328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79329       };
79330     }
79331   }
79332   jresult = (void *)result;
79333   return jresult;
79334 }
79335
79336
79337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
79338   void * jresult ;
79339   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
79340   Dali::Toolkit::GaussianBlurView *result = 0 ;
79341
79342   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79343   if (!arg1) {
79344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79345     return 0;
79346   }
79347   {
79348     try {
79349       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
79350     } catch (std::out_of_range& e) {
79351       {
79352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79353       };
79354     } catch (std::exception& e) {
79355       {
79356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79357       };
79358     } catch (...) {
79359       {
79360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79361       };
79362     }
79363   }
79364   jresult = (void *)result;
79365   return jresult;
79366 }
79367
79368
79369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
79370   void * jresult ;
79371   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79372   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
79373   Dali::Toolkit::GaussianBlurView *result = 0 ;
79374
79375   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79376   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
79377   if (!arg2) {
79378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
79379     return 0;
79380   }
79381   {
79382     try {
79383       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
79384     } catch (std::out_of_range& e) {
79385       {
79386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79387       };
79388     } catch (std::exception& e) {
79389       {
79390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79391       };
79392     } catch (...) {
79393       {
79394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79395       };
79396     }
79397   }
79398   jresult = (void *)result;
79399   return jresult;
79400 }
79401
79402
79403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
79404   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79405
79406   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79407   {
79408     try {
79409       delete arg1;
79410     } catch (std::out_of_range& e) {
79411       {
79412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79413       };
79414     } catch (std::exception& e) {
79415       {
79416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79417       };
79418     } catch (...) {
79419       {
79420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79421       };
79422     }
79423   }
79424 }
79425
79426
79427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
79428   void * jresult ;
79429   Dali::BaseHandle arg1 ;
79430   Dali::BaseHandle *argp1 ;
79431   Dali::Toolkit::GaussianBlurView result;
79432
79433   argp1 = (Dali::BaseHandle *)jarg1;
79434   if (!argp1) {
79435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79436     return 0;
79437   }
79438   arg1 = *argp1;
79439   {
79440     try {
79441       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
79442     } catch (std::out_of_range& e) {
79443       {
79444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79445       };
79446     } catch (std::exception& e) {
79447       {
79448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79449       };
79450     } catch (...) {
79451       {
79452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79453       };
79454     }
79455   }
79456   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79457   return jresult;
79458 }
79459
79460
79461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
79462   void * jresult ;
79463   Dali::Toolkit::GaussianBlurView result;
79464
79465   {
79466     try {
79467       result = Dali::Toolkit::GaussianBlurView::New();
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::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79483   return jresult;
79484 }
79485
79486
79487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
79488   void * jresult ;
79489   unsigned int arg1 ;
79490   float arg2 ;
79491   Dali::Pixel::Format arg3 ;
79492   float arg4 ;
79493   float arg5 ;
79494   bool arg6 ;
79495   Dali::Toolkit::GaussianBlurView result;
79496
79497   arg1 = (unsigned int)jarg1;
79498   arg2 = (float)jarg2;
79499   arg3 = (Dali::Pixel::Format)jarg3;
79500   arg4 = (float)jarg4;
79501   arg5 = (float)jarg5;
79502   arg6 = jarg6 ? true : false;
79503   {
79504     try {
79505       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
79506     } catch (std::out_of_range& e) {
79507       {
79508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79509       };
79510     } catch (std::exception& e) {
79511       {
79512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79513       };
79514     } catch (...) {
79515       {
79516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79517       };
79518     }
79519   }
79520   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
79526   void * jresult ;
79527   unsigned int arg1 ;
79528   float arg2 ;
79529   Dali::Pixel::Format arg3 ;
79530   float arg4 ;
79531   float arg5 ;
79532   Dali::Toolkit::GaussianBlurView result;
79533
79534   arg1 = (unsigned int)jarg1;
79535   arg2 = (float)jarg2;
79536   arg3 = (Dali::Pixel::Format)jarg3;
79537   arg4 = (float)jarg4;
79538   arg5 = (float)jarg5;
79539   {
79540     try {
79541       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
79542     } catch (std::out_of_range& e) {
79543       {
79544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79545       };
79546     } catch (std::exception& e) {
79547       {
79548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79549       };
79550     } catch (...) {
79551       {
79552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79553       };
79554     }
79555   }
79556   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
79557   return jresult;
79558 }
79559
79560
79561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
79562   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79563   Dali::Actor arg2 ;
79564   Dali::Actor *argp2 ;
79565
79566   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79567   argp2 = (Dali::Actor *)jarg2;
79568   if (!argp2) {
79569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79570     return ;
79571   }
79572   arg2 = *argp2;
79573   {
79574     try {
79575       (arg1)->Add(arg2);
79576     } catch (std::out_of_range& e) {
79577       {
79578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79579       };
79580     } catch (std::exception& e) {
79581       {
79582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79583       };
79584     } catch (...) {
79585       {
79586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79587       };
79588     }
79589   }
79590 }
79591
79592
79593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
79594   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79595   Dali::Actor arg2 ;
79596   Dali::Actor *argp2 ;
79597
79598   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79599   argp2 = (Dali::Actor *)jarg2;
79600   if (!argp2) {
79601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79602     return ;
79603   }
79604   arg2 = *argp2;
79605   {
79606     try {
79607       (arg1)->Remove(arg2);
79608     } catch (std::out_of_range& e) {
79609       {
79610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79611       };
79612     } catch (std::exception& e) {
79613       {
79614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79615       };
79616     } catch (...) {
79617       {
79618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79619       };
79620     }
79621   }
79622 }
79623
79624
79625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
79626   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79627
79628   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79629   {
79630     try {
79631       (arg1)->Activate();
79632     } catch (std::out_of_range& e) {
79633       {
79634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79635       };
79636     } catch (std::exception& e) {
79637       {
79638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79639       };
79640     } catch (...) {
79641       {
79642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79643       };
79644     }
79645   }
79646 }
79647
79648
79649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
79650   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79651
79652   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79653   {
79654     try {
79655       (arg1)->ActivateOnce();
79656     } catch (std::out_of_range& e) {
79657       {
79658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79659       };
79660     } catch (std::exception& e) {
79661       {
79662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79663       };
79664     } catch (...) {
79665       {
79666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79667       };
79668     }
79669   }
79670 }
79671
79672
79673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
79674   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79675
79676   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79677   {
79678     try {
79679       (arg1)->Deactivate();
79680     } catch (std::out_of_range& e) {
79681       {
79682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79683       };
79684     } catch (std::exception& e) {
79685       {
79686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79687       };
79688     } catch (...) {
79689       {
79690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79691       };
79692     }
79693   }
79694 }
79695
79696
79697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
79698   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79699   Dali::Image arg2 ;
79700   Dali::FrameBufferImage arg3 ;
79701   Dali::Image *argp2 ;
79702   Dali::FrameBufferImage *argp3 ;
79703
79704   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79705   argp2 = (Dali::Image *)jarg2;
79706   if (!argp2) {
79707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
79708     return ;
79709   }
79710   arg2 = *argp2;
79711   argp3 = (Dali::FrameBufferImage *)jarg3;
79712   if (!argp3) {
79713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
79714     return ;
79715   }
79716   arg3 = *argp3;
79717   {
79718     try {
79719       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
79720     } catch (std::out_of_range& e) {
79721       {
79722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79723       };
79724     } catch (std::exception& e) {
79725       {
79726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79727       };
79728     } catch (...) {
79729       {
79730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79731       };
79732     }
79733   }
79734 }
79735
79736
79737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
79738   int jresult ;
79739   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79740   Dali::Property::Index result;
79741
79742   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79743   {
79744     try {
79745       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
79746     } catch (std::out_of_range& e) {
79747       {
79748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79749       };
79750     } catch (std::exception& e) {
79751       {
79752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79753       };
79754     } catch (...) {
79755       {
79756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79757       };
79758     }
79759   }
79760   jresult = result;
79761   return jresult;
79762 }
79763
79764
79765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
79766   void * jresult ;
79767   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79768   Dali::FrameBufferImage result;
79769
79770   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79771   {
79772     try {
79773       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
79774     } catch (std::out_of_range& e) {
79775       {
79776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (std::exception& e) {
79779       {
79780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (...) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79785       };
79786     }
79787   }
79788   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
79794   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79795   Dali::Vector4 *arg2 = 0 ;
79796
79797   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79798   arg2 = (Dali::Vector4 *)jarg2;
79799   if (!arg2) {
79800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
79801     return ;
79802   }
79803   {
79804     try {
79805       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
79806     } catch (std::out_of_range& e) {
79807       {
79808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79809       };
79810     } catch (std::exception& e) {
79811       {
79812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79813       };
79814     } catch (...) {
79815       {
79816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79817       };
79818     }
79819   }
79820 }
79821
79822
79823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
79824   void * jresult ;
79825   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79826   Dali::Vector4 result;
79827
79828   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79829   {
79830     try {
79831       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
79832     } catch (std::out_of_range& e) {
79833       {
79834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79835       };
79836     } catch (std::exception& e) {
79837       {
79838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79839       };
79840     } catch (...) {
79841       {
79842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79843       };
79844     }
79845   }
79846   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
79847   return jresult;
79848 }
79849
79850
79851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
79852   void * jresult ;
79853   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
79854   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
79855
79856   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
79857   {
79858     try {
79859       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
79860     } catch (std::out_of_range& e) {
79861       {
79862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79863       };
79864     } catch (std::exception& e) {
79865       {
79866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79867       };
79868     } catch (...) {
79869       {
79870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79871       };
79872     }
79873   }
79874   jresult = (void *)result;
79875   return jresult;
79876 }
79877
79878
79879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
79880   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79881
79882   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79883   {
79884     try {
79885       delete arg1;
79886     } catch (std::out_of_range& e) {
79887       {
79888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79889       };
79890     } catch (std::exception& e) {
79891       {
79892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79893       };
79894     } catch (...) {
79895       {
79896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79897       };
79898     }
79899   }
79900 }
79901
79902
79903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
79904   unsigned int jresult ;
79905   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79906   unsigned int result;
79907
79908   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79909   {
79910     try {
79911       result = (unsigned int)(arg1)->GetNumberOfPages();
79912     } catch (std::out_of_range& e) {
79913       {
79914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79915       };
79916     } catch (std::exception& e) {
79917       {
79918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79919       };
79920     } catch (...) {
79921       {
79922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79923       };
79924     }
79925   }
79926   jresult = result;
79927   return jresult;
79928 }
79929
79930
79931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
79932   void * jresult ;
79933   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
79934   unsigned int arg2 ;
79935   Dali::Texture result;
79936
79937   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
79938   arg2 = (unsigned int)jarg2;
79939   {
79940     try {
79941       result = (arg1)->NewPage(arg2);
79942     } catch (std::out_of_range& e) {
79943       {
79944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79945       };
79946     } catch (std::exception& e) {
79947       {
79948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79949       };
79950     } catch (...) {
79951       {
79952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79953       };
79954     }
79955   }
79956   jresult = new Dali::Texture((const Dali::Texture &)result);
79957   return jresult;
79958 }
79959
79960
79961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
79962   int jresult ;
79963   int result;
79964
79965   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
79966   jresult = (int)result;
79967   return jresult;
79968 }
79969
79970
79971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
79972   int jresult ;
79973   int result;
79974
79975   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
79976   jresult = (int)result;
79977   return jresult;
79978 }
79979
79980
79981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
79982   int jresult ;
79983   int result;
79984
79985   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
79986   jresult = (int)result;
79987   return jresult;
79988 }
79989
79990
79991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
79992   void * jresult ;
79993   Dali::Toolkit::PageTurnView::Property *result = 0 ;
79994
79995   {
79996     try {
79997       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
79998     } catch (std::out_of_range& e) {
79999       {
80000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80001       };
80002     } catch (std::exception& e) {
80003       {
80004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (...) {
80007       {
80008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80009       };
80010     }
80011   }
80012   jresult = (void *)result;
80013   return jresult;
80014 }
80015
80016
80017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
80018   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
80019
80020   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
80021   {
80022     try {
80023       delete arg1;
80024     } catch (std::out_of_range& e) {
80025       {
80026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80027       };
80028     } catch (std::exception& e) {
80029       {
80030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80031       };
80032     } catch (...) {
80033       {
80034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80035       };
80036     }
80037   }
80038 }
80039
80040
80041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
80042   void * jresult ;
80043   Dali::Toolkit::PageTurnView *result = 0 ;
80044
80045   {
80046     try {
80047       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
80048     } catch (std::out_of_range& e) {
80049       {
80050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80051       };
80052     } catch (std::exception& e) {
80053       {
80054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80055       };
80056     } catch (...) {
80057       {
80058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80059       };
80060     }
80061   }
80062   jresult = (void *)result;
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
80068   void * jresult ;
80069   Dali::Toolkit::PageTurnView *arg1 = 0 ;
80070   Dali::Toolkit::PageTurnView *result = 0 ;
80071
80072   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80073   if (!arg1) {
80074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
80075     return 0;
80076   }
80077   {
80078     try {
80079       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
80080     } catch (std::out_of_range& e) {
80081       {
80082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (std::exception& e) {
80085       {
80086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80087       };
80088     } catch (...) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80091       };
80092     }
80093   }
80094   jresult = (void *)result;
80095   return jresult;
80096 }
80097
80098
80099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
80100   void * jresult ;
80101   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80102   Dali::Toolkit::PageTurnView *arg2 = 0 ;
80103   Dali::Toolkit::PageTurnView *result = 0 ;
80104
80105   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80106   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
80107   if (!arg2) {
80108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
80109     return 0;
80110   }
80111   {
80112     try {
80113       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
80114     } catch (std::out_of_range& e) {
80115       {
80116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80117       };
80118     } catch (std::exception& e) {
80119       {
80120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80121       };
80122     } catch (...) {
80123       {
80124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80125       };
80126     }
80127   }
80128   jresult = (void *)result;
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
80134   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80135
80136   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80137   {
80138     try {
80139       delete arg1;
80140     } catch (std::out_of_range& e) {
80141       {
80142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80143       };
80144     } catch (std::exception& e) {
80145       {
80146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80147       };
80148     } catch (...) {
80149       {
80150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80151       };
80152     }
80153   }
80154 }
80155
80156
80157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
80158   void * jresult ;
80159   Dali::BaseHandle arg1 ;
80160   Dali::BaseHandle *argp1 ;
80161   Dali::Toolkit::PageTurnView result;
80162
80163   argp1 = (Dali::BaseHandle *)jarg1;
80164   if (!argp1) {
80165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80166     return 0;
80167   }
80168   arg1 = *argp1;
80169   {
80170     try {
80171       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
80172     } catch (std::out_of_range& e) {
80173       {
80174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80175       };
80176     } catch (std::exception& e) {
80177       {
80178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80179       };
80180     } catch (...) {
80181       {
80182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80183       };
80184     }
80185   }
80186   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
80187   return jresult;
80188 }
80189
80190
80191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
80192   void * jresult ;
80193   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80194   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80195
80196   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80197   {
80198     try {
80199       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
80200     } catch (std::out_of_range& e) {
80201       {
80202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80203       };
80204     } catch (std::exception& e) {
80205       {
80206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80207       };
80208     } catch (...) {
80209       {
80210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80211       };
80212     }
80213   }
80214   jresult = (void *)result;
80215   return jresult;
80216 }
80217
80218
80219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
80220   void * jresult ;
80221   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80222   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
80223
80224   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80225   {
80226     try {
80227       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
80228     } catch (std::out_of_range& e) {
80229       {
80230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80231       };
80232     } catch (std::exception& e) {
80233       {
80234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80235       };
80236     } catch (...) {
80237       {
80238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80239       };
80240     }
80241   }
80242   jresult = (void *)result;
80243   return jresult;
80244 }
80245
80246
80247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
80248   void * jresult ;
80249   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80250   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80251
80252   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80253   {
80254     try {
80255       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
80256     } catch (std::out_of_range& e) {
80257       {
80258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80259       };
80260     } catch (std::exception& e) {
80261       {
80262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80263       };
80264     } catch (...) {
80265       {
80266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80267       };
80268     }
80269   }
80270   jresult = (void *)result;
80271   return jresult;
80272 }
80273
80274
80275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
80276   void * jresult ;
80277   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
80278   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
80279
80280   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
80281   {
80282     try {
80283       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
80284     } catch (std::out_of_range& e) {
80285       {
80286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80287       };
80288     } catch (std::exception& e) {
80289       {
80290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80291       };
80292     } catch (...) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80295       };
80296     }
80297   }
80298   jresult = (void *)result;
80299   return jresult;
80300 }
80301
80302
80303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
80304   void * jresult ;
80305   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80306
80307   {
80308     try {
80309       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
80310     } catch (std::out_of_range& e) {
80311       {
80312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80313       };
80314     } catch (std::exception& e) {
80315       {
80316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80317       };
80318     } catch (...) {
80319       {
80320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80321       };
80322     }
80323   }
80324   jresult = (void *)result;
80325   return jresult;
80326 }
80327
80328
80329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
80330   void * jresult ;
80331   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
80332   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80333
80334   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80335   if (!arg1) {
80336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80337     return 0;
80338   }
80339   {
80340     try {
80341       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
80342     } catch (std::out_of_range& e) {
80343       {
80344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80345       };
80346     } catch (std::exception& e) {
80347       {
80348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80349       };
80350     } catch (...) {
80351       {
80352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80353       };
80354     }
80355   }
80356   jresult = (void *)result;
80357   return jresult;
80358 }
80359
80360
80361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
80362   void * jresult ;
80363   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80364   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
80365   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
80366
80367   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80368   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
80369   if (!arg2) {
80370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
80371     return 0;
80372   }
80373   {
80374     try {
80375       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
80376     } catch (std::out_of_range& e) {
80377       {
80378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80379       };
80380     } catch (std::exception& e) {
80381       {
80382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80383       };
80384     } catch (...) {
80385       {
80386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80387       };
80388     }
80389   }
80390   jresult = (void *)result;
80391   return jresult;
80392 }
80393
80394
80395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
80396   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
80397
80398   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
80399   {
80400     try {
80401       delete arg1;
80402     } catch (std::out_of_range& e) {
80403       {
80404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80405       };
80406     } catch (std::exception& e) {
80407       {
80408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80409       };
80410     } catch (...) {
80411       {
80412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80413       };
80414     }
80415   }
80416 }
80417
80418
80419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
80420   void * jresult ;
80421   Dali::Toolkit::PageFactory *arg1 = 0 ;
80422   Dali::Vector2 *arg2 = 0 ;
80423   Dali::Toolkit::PageTurnLandscapeView result;
80424
80425   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80426   if (!arg1) {
80427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80428     return 0;
80429   }
80430   arg2 = (Dali::Vector2 *)jarg2;
80431   if (!arg2) {
80432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80433     return 0;
80434   }
80435   {
80436     try {
80437       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
80438     } catch (std::out_of_range& e) {
80439       {
80440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (std::exception& e) {
80443       {
80444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80449       };
80450     }
80451   }
80452   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80453   return jresult;
80454 }
80455
80456
80457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
80458   void * jresult ;
80459   Dali::BaseHandle arg1 ;
80460   Dali::BaseHandle *argp1 ;
80461   Dali::Toolkit::PageTurnLandscapeView result;
80462
80463   argp1 = (Dali::BaseHandle *)jarg1;
80464   if (!argp1) {
80465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80466     return 0;
80467   }
80468   arg1 = *argp1;
80469   {
80470     try {
80471       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
80472     } catch (std::out_of_range& e) {
80473       {
80474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80475       };
80476     } catch (std::exception& e) {
80477       {
80478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80479       };
80480     } catch (...) {
80481       {
80482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80483       };
80484     }
80485   }
80486   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
80487   return jresult;
80488 }
80489
80490
80491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
80492   void * jresult ;
80493   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80494
80495   {
80496     try {
80497       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
80498     } catch (std::out_of_range& e) {
80499       {
80500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80501       };
80502     } catch (std::exception& e) {
80503       {
80504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80505       };
80506     } catch (...) {
80507       {
80508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80509       };
80510     }
80511   }
80512   jresult = (void *)result;
80513   return jresult;
80514 }
80515
80516
80517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
80518   void * jresult ;
80519   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
80520   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80521
80522   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80523   if (!arg1) {
80524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80525     return 0;
80526   }
80527   {
80528     try {
80529       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
80530     } catch (std::out_of_range& e) {
80531       {
80532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80533       };
80534     } catch (std::exception& e) {
80535       {
80536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80537       };
80538     } catch (...) {
80539       {
80540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80541       };
80542     }
80543   }
80544   jresult = (void *)result;
80545   return jresult;
80546 }
80547
80548
80549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
80550   void * jresult ;
80551   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80552   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
80553   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
80554
80555   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80556   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
80557   if (!arg2) {
80558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
80559     return 0;
80560   }
80561   {
80562     try {
80563       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
80564     } catch (std::out_of_range& e) {
80565       {
80566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80567       };
80568     } catch (std::exception& e) {
80569       {
80570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80571       };
80572     } catch (...) {
80573       {
80574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80575       };
80576     }
80577   }
80578   jresult = (void *)result;
80579   return jresult;
80580 }
80581
80582
80583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
80584   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
80585
80586   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
80587   {
80588     try {
80589       delete arg1;
80590     } catch (std::out_of_range& e) {
80591       {
80592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80593       };
80594     } catch (std::exception& e) {
80595       {
80596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80597       };
80598     } catch (...) {
80599       {
80600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80601       };
80602     }
80603   }
80604 }
80605
80606
80607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
80608   void * jresult ;
80609   Dali::Toolkit::PageFactory *arg1 = 0 ;
80610   Dali::Vector2 *arg2 = 0 ;
80611   Dali::Toolkit::PageTurnPortraitView result;
80612
80613   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
80614   if (!arg1) {
80615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
80616     return 0;
80617   }
80618   arg2 = (Dali::Vector2 *)jarg2;
80619   if (!arg2) {
80620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80621     return 0;
80622   }
80623   {
80624     try {
80625       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
80626     } catch (std::out_of_range& e) {
80627       {
80628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80629       };
80630     } catch (std::exception& e) {
80631       {
80632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80633       };
80634     } catch (...) {
80635       {
80636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80637       };
80638     }
80639   }
80640   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80641   return jresult;
80642 }
80643
80644
80645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
80646   void * jresult ;
80647   Dali::BaseHandle arg1 ;
80648   Dali::BaseHandle *argp1 ;
80649   Dali::Toolkit::PageTurnPortraitView result;
80650
80651   argp1 = (Dali::BaseHandle *)jarg1;
80652   if (!argp1) {
80653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80654     return 0;
80655   }
80656   arg1 = *argp1;
80657   {
80658     try {
80659       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
80660     } catch (std::out_of_range& e) {
80661       {
80662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80663       };
80664     } catch (std::exception& e) {
80665       {
80666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80667       };
80668     } catch (...) {
80669       {
80670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80671       };
80672     }
80673   }
80674   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
80675   return jresult;
80676 }
80677
80678
80679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
80680   int jresult ;
80681   int result;
80682
80683   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
80684   jresult = (int)result;
80685   return jresult;
80686 }
80687
80688
80689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
80690   int jresult ;
80691   int result;
80692
80693   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
80694   jresult = (int)result;
80695   return jresult;
80696 }
80697
80698
80699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
80700   int jresult ;
80701   int result;
80702
80703   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
80704   jresult = (int)result;
80705   return jresult;
80706 }
80707
80708
80709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
80710   void * jresult ;
80711   Dali::Toolkit::ToggleButton::Property *result = 0 ;
80712
80713   {
80714     try {
80715       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80727       };
80728     }
80729   }
80730   jresult = (void *)result;
80731   return jresult;
80732 }
80733
80734
80735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
80736   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
80737
80738   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
80739   {
80740     try {
80741       delete arg1;
80742     } catch (std::out_of_range& e) {
80743       {
80744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80745       };
80746     } catch (std::exception& e) {
80747       {
80748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80749       };
80750     } catch (...) {
80751       {
80752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80753       };
80754     }
80755   }
80756 }
80757
80758
80759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
80760   void * jresult ;
80761   Dali::Toolkit::ToggleButton *result = 0 ;
80762
80763   {
80764     try {
80765       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
80766     } catch (std::out_of_range& e) {
80767       {
80768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80769       };
80770     } catch (std::exception& e) {
80771       {
80772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80773       };
80774     } catch (...) {
80775       {
80776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80777       };
80778     }
80779   }
80780   jresult = (void *)result;
80781   return jresult;
80782 }
80783
80784
80785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
80786   void * jresult ;
80787   Dali::Toolkit::ToggleButton *arg1 = 0 ;
80788   Dali::Toolkit::ToggleButton *result = 0 ;
80789
80790   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80791   if (!arg1) {
80792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80793     return 0;
80794   }
80795   {
80796     try {
80797       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
80798     } catch (std::out_of_range& e) {
80799       {
80800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80801       };
80802     } catch (std::exception& e) {
80803       {
80804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80805       };
80806     } catch (...) {
80807       {
80808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80809       };
80810     }
80811   }
80812   jresult = (void *)result;
80813   return jresult;
80814 }
80815
80816
80817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
80818   void * jresult ;
80819   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80820   Dali::Toolkit::ToggleButton *arg2 = 0 ;
80821   Dali::Toolkit::ToggleButton *result = 0 ;
80822
80823   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80824   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
80825   if (!arg2) {
80826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
80827     return 0;
80828   }
80829   {
80830     try {
80831       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
80832     } catch (std::out_of_range& e) {
80833       {
80834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80835       };
80836     } catch (std::exception& e) {
80837       {
80838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80839       };
80840     } catch (...) {
80841       {
80842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80843       };
80844     }
80845   }
80846   jresult = (void *)result;
80847   return jresult;
80848 }
80849
80850
80851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
80852   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
80853
80854   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
80855   {
80856     try {
80857       delete arg1;
80858     } catch (std::out_of_range& e) {
80859       {
80860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80861       };
80862     } catch (std::exception& e) {
80863       {
80864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80865       };
80866     } catch (...) {
80867       {
80868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80869       };
80870     }
80871   }
80872 }
80873
80874
80875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
80876   void * jresult ;
80877   Dali::Toolkit::ToggleButton result;
80878
80879   {
80880     try {
80881       result = Dali::Toolkit::ToggleButton::New();
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80889       };
80890     } catch (...) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80893       };
80894     }
80895   }
80896   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80897   return jresult;
80898 }
80899
80900
80901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
80902   void * jresult ;
80903   Dali::BaseHandle arg1 ;
80904   Dali::BaseHandle *argp1 ;
80905   Dali::Toolkit::ToggleButton result;
80906
80907   argp1 = (Dali::BaseHandle *)jarg1;
80908   if (!argp1) {
80909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80910     return 0;
80911   }
80912   arg1 = *argp1;
80913   {
80914     try {
80915       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
80916     } catch (std::out_of_range& e) {
80917       {
80918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80919       };
80920     } catch (std::exception& e) {
80921       {
80922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80923       };
80924     } catch (...) {
80925       {
80926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80927       };
80928     }
80929   }
80930   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
80931   return jresult;
80932 }
80933
80934
80935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
80936   void * jresult ;
80937   Dali::Toolkit::Visual::Base *result = 0 ;
80938
80939   {
80940     try {
80941       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (...) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80953       };
80954     }
80955   }
80956   jresult = (void *)result;
80957   return jresult;
80958 }
80959
80960
80961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
80962   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
80963
80964   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80965   {
80966     try {
80967       delete arg1;
80968     } catch (std::out_of_range& e) {
80969       {
80970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80971       };
80972     } catch (std::exception& e) {
80973       {
80974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80979       };
80980     }
80981   }
80982 }
80983
80984
80985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
80986   void * jresult ;
80987   Dali::Toolkit::Visual::Base *arg1 = 0 ;
80988   Dali::Toolkit::Visual::Base *result = 0 ;
80989
80990   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
80991   if (!arg1) {
80992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
80993     return 0;
80994   }
80995   {
80996     try {
80997       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
80998     } catch (std::out_of_range& e) {
80999       {
81000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81001       };
81002     } catch (std::exception& e) {
81003       {
81004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81005       };
81006     } catch (...) {
81007       {
81008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81009       };
81010     }
81011   }
81012   jresult = (void *)result;
81013   return jresult;
81014 }
81015
81016
81017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
81018   void * jresult ;
81019   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81020   Dali::Toolkit::Visual::Base *arg2 = 0 ;
81021   Dali::Toolkit::Visual::Base *result = 0 ;
81022
81023   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81024   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
81025   if (!arg2) {
81026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
81027     return 0;
81028   }
81029   {
81030     try {
81031       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
81032     } catch (std::out_of_range& e) {
81033       {
81034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81035       };
81036     } catch (std::exception& e) {
81037       {
81038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (...) {
81041       {
81042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81043       };
81044     }
81045   }
81046   jresult = (void *)result;
81047   return jresult;
81048 }
81049
81050
81051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
81052   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81053   std::string *arg2 = 0 ;
81054
81055   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81056   if (!jarg2) {
81057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81058     return ;
81059   }
81060   std::string arg2_str(jarg2);
81061   arg2 = &arg2_str;
81062   {
81063     try {
81064       (arg1)->SetName((std::string const &)*arg2);
81065     } catch (std::out_of_range& e) {
81066       {
81067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81068       };
81069     } catch (std::exception& e) {
81070       {
81071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81072       };
81073     } catch (...) {
81074       {
81075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81076       };
81077     }
81078   }
81079
81080   //argout typemap for const std::string&
81081
81082 }
81083
81084
81085 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
81086   char * jresult ;
81087   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81088   std::string *result = 0 ;
81089
81090   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81091   {
81092     try {
81093       result = (std::string *) &(arg1)->GetName();
81094     } catch (std::out_of_range& e) {
81095       {
81096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81097       };
81098     } catch (std::exception& e) {
81099       {
81100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81101       };
81102     } catch (...) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81105       };
81106     }
81107   }
81108   jresult = SWIG_csharp_string_callback(result->c_str());
81109   return jresult;
81110 }
81111
81112
81113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
81114   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81115   Dali::Property::Map *arg2 = 0 ;
81116   Dali::Size arg3 ;
81117   Dali::Size *argp3 ;
81118
81119   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81120   arg2 = (Dali::Property::Map *)jarg2;
81121   if (!arg2) {
81122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
81123     return ;
81124   }
81125   argp3 = (Dali::Size *)jarg3;
81126   if (!argp3) {
81127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
81128     return ;
81129   }
81130   arg3 = *argp3;
81131   {
81132     try {
81133       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
81134     } catch (std::out_of_range& e) {
81135       {
81136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81137       };
81138     } catch (std::exception& e) {
81139       {
81140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81141       };
81142     } catch (...) {
81143       {
81144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81145       };
81146     }
81147   }
81148 }
81149
81150
81151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
81152   float jresult ;
81153   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81154   float arg2 ;
81155   float result;
81156
81157   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81158   arg2 = (float)jarg2;
81159   {
81160     try {
81161       result = (float)(arg1)->GetHeightForWidth(arg2);
81162     } catch (std::out_of_range& e) {
81163       {
81164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81165       };
81166     } catch (std::exception& e) {
81167       {
81168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81169       };
81170     } catch (...) {
81171       {
81172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81173       };
81174     }
81175   }
81176   jresult = result;
81177   return jresult;
81178 }
81179
81180
81181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
81182   float jresult ;
81183   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81184   float arg2 ;
81185   float result;
81186
81187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81188   arg2 = (float)jarg2;
81189   {
81190     try {
81191       result = (float)(arg1)->GetWidthForHeight(arg2);
81192     } catch (std::out_of_range& e) {
81193       {
81194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (std::exception& e) {
81197       {
81198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (...) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81203       };
81204     }
81205   }
81206   jresult = result;
81207   return jresult;
81208 }
81209
81210
81211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
81212   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81213   Dali::Vector2 *arg2 = 0 ;
81214
81215   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81216   arg2 = (Dali::Vector2 *)jarg2;
81217   if (!arg2) {
81218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
81219     return ;
81220   }
81221   {
81222     try {
81223       (arg1)->GetNaturalSize(*arg2);
81224     } catch (std::out_of_range& e) {
81225       {
81226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81227       };
81228     } catch (std::exception& e) {
81229       {
81230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81231       };
81232     } catch (...) {
81233       {
81234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81235       };
81236     }
81237   }
81238 }
81239
81240
81241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
81242   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81243   float arg2 ;
81244
81245   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81246   arg2 = (int)jarg2;
81247   {
81248     try {
81249       (arg1)->SetDepthIndex(arg2);
81250     } catch (std::out_of_range& e) {
81251       {
81252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81253       };
81254     } catch (std::exception& e) {
81255       {
81256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81257       };
81258     } catch (...) {
81259       {
81260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81261       };
81262     }
81263   }
81264 }
81265
81266
81267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
81268   int jresult ;
81269   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81270   int result;
81271
81272   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81273   {
81274     try {
81275       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
81276     } catch (std::out_of_range& e) {
81277       {
81278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (std::exception& e) {
81281       {
81282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81283       };
81284     } catch (...) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81287       };
81288     }
81289   }
81290   jresult = result;
81291   return jresult;
81292 }
81293
81294
81295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
81296   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
81297   Dali::Property::Map *arg2 = 0 ;
81298
81299   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
81300   arg2 = (Dali::Property::Map *)jarg2;
81301   if (!arg2) {
81302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
81303     return ;
81304   }
81305   {
81306     try {
81307       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
81308     } catch (std::out_of_range& e) {
81309       {
81310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81311       };
81312     } catch (std::exception& e) {
81313       {
81314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81315       };
81316     } catch (...) {
81317       {
81318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81319       };
81320     }
81321   }
81322 }
81323
81324
81325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
81326   void * jresult ;
81327   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
81328   Dali::Toolkit::Visual::Base *result = 0 ;
81329
81330   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
81331   {
81332     try {
81333       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
81334     } catch (std::out_of_range& e) {
81335       {
81336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81337       };
81338     } catch (std::exception& e) {
81339       {
81340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81341       };
81342     } catch (...) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81345       };
81346     }
81347   }
81348   jresult = (void *)result;
81349   return jresult;
81350 }
81351
81352
81353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
81354   void * jresult ;
81355   Dali::Toolkit::VisualFactory result;
81356
81357   {
81358     try {
81359       result = Dali::Toolkit::VisualFactory::Get();
81360     } catch (std::out_of_range& e) {
81361       {
81362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81363       };
81364     } catch (std::exception& e) {
81365       {
81366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81367       };
81368     } catch (...) {
81369       {
81370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81371       };
81372     }
81373   }
81374   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
81375   return jresult;
81376 }
81377
81378
81379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
81380   void * jresult ;
81381   Dali::Toolkit::VisualFactory *result = 0 ;
81382
81383   {
81384     try {
81385       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (...) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81397       };
81398     }
81399   }
81400   jresult = (void *)result;
81401   return jresult;
81402 }
81403
81404
81405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
81406   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81407
81408   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81409   {
81410     try {
81411       delete arg1;
81412     } catch (std::out_of_range& e) {
81413       {
81414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81415       };
81416     } catch (std::exception& e) {
81417       {
81418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81419       };
81420     } catch (...) {
81421       {
81422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81423       };
81424     }
81425   }
81426 }
81427
81428
81429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
81430   void * jresult ;
81431   Dali::Toolkit::VisualFactory *arg1 = 0 ;
81432   Dali::Toolkit::VisualFactory *result = 0 ;
81433
81434   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81435   if (!arg1) {
81436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81437     return 0;
81438   }
81439   {
81440     try {
81441       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
81442     } catch (std::out_of_range& e) {
81443       {
81444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81445       };
81446     } catch (std::exception& e) {
81447       {
81448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81449       };
81450     } catch (...) {
81451       {
81452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81453       };
81454     }
81455   }
81456   jresult = (void *)result;
81457   return jresult;
81458 }
81459
81460
81461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
81462   void * jresult ;
81463   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81464   Dali::Toolkit::VisualFactory *arg2 = 0 ;
81465   Dali::Toolkit::VisualFactory *result = 0 ;
81466
81467   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81468   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
81469   if (!arg2) {
81470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
81471     return 0;
81472   }
81473   {
81474     try {
81475       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81483       };
81484     } catch (...) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81487       };
81488     }
81489   }
81490   jresult = (void *)result;
81491   return jresult;
81492 }
81493
81494
81495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
81496   void * jresult ;
81497   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81498   Dali::Property::Map *arg2 = 0 ;
81499   Dali::Toolkit::Visual::Base result;
81500
81501   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81502   arg2 = (Dali::Property::Map *)jarg2;
81503   if (!arg2) {
81504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
81505     return 0;
81506   }
81507   {
81508     try {
81509       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
81510     } catch (std::out_of_range& e) {
81511       {
81512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81513       };
81514     } catch (std::exception& e) {
81515       {
81516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81517       };
81518     } catch (...) {
81519       {
81520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81521       };
81522     }
81523   }
81524   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81525   return jresult;
81526 }
81527
81528
81529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
81530   void * jresult ;
81531   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81532   Dali::Image *arg2 = 0 ;
81533   Dali::Toolkit::Visual::Base result;
81534
81535   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81536   arg2 = (Dali::Image *)jarg2;
81537   if (!arg2) {
81538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
81539     return 0;
81540   }
81541   {
81542     try {
81543       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
81544     } catch (std::out_of_range& e) {
81545       {
81546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81547       };
81548     } catch (std::exception& e) {
81549       {
81550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81551       };
81552     } catch (...) {
81553       {
81554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81555       };
81556     }
81557   }
81558   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81559   return jresult;
81560 }
81561
81562
81563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
81564   void * jresult ;
81565   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
81566   std::string *arg2 = 0 ;
81567   Dali::ImageDimensions arg3 ;
81568   Dali::ImageDimensions *argp3 ;
81569   Dali::Toolkit::Visual::Base result;
81570
81571   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
81572   if (!jarg2) {
81573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81574     return 0;
81575   }
81576   std::string arg2_str(jarg2);
81577   arg2 = &arg2_str;
81578   argp3 = (Dali::ImageDimensions *)jarg3;
81579   if (!argp3) {
81580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81581     return 0;
81582   }
81583   arg3 = *argp3;
81584   {
81585     try {
81586       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
81587     } catch (std::out_of_range& e) {
81588       {
81589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81590       };
81591     } catch (std::exception& e) {
81592       {
81593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81594       };
81595     } catch (...) {
81596       {
81597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81598       };
81599     }
81600   }
81601   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
81602
81603   //argout typemap for const std::string&
81604
81605   return jresult;
81606 }
81607
81608
81609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
81610   void * jresult ;
81611   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81612
81613   {
81614     try {
81615       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
81616     } catch (std::out_of_range& e) {
81617       {
81618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81619       };
81620     } catch (std::exception& e) {
81621       {
81622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81623       };
81624     } catch (...) {
81625       {
81626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81627       };
81628     }
81629   }
81630   jresult = (void *)result;
81631   return jresult;
81632 }
81633
81634
81635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
81636   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81637
81638   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81639   {
81640     try {
81641       delete arg1;
81642     } catch (std::out_of_range& e) {
81643       {
81644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81645       };
81646     } catch (std::exception& e) {
81647       {
81648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81649       };
81650     } catch (...) {
81651       {
81652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81653       };
81654     }
81655   }
81656 }
81657
81658
81659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
81660   void * jresult ;
81661   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
81662   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81663
81664   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81665   if (!arg1) {
81666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81667     return 0;
81668   }
81669   {
81670     try {
81671       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
81672     } catch (std::out_of_range& e) {
81673       {
81674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (std::exception& e) {
81677       {
81678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81683       };
81684     }
81685   }
81686   jresult = (void *)result;
81687   return jresult;
81688 }
81689
81690
81691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
81692   void * jresult ;
81693   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81694   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
81695   Dali::Toolkit::AsyncImageLoader *result = 0 ;
81696
81697   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81698   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
81699   if (!arg2) {
81700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
81701     return 0;
81702   }
81703   {
81704     try {
81705       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
81706     } catch (std::out_of_range& e) {
81707       {
81708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81709       };
81710     } catch (std::exception& e) {
81711       {
81712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81713       };
81714     } catch (...) {
81715       {
81716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81717       };
81718     }
81719   }
81720   jresult = (void *)result;
81721   return jresult;
81722 }
81723
81724
81725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
81726   void * jresult ;
81727   Dali::Toolkit::AsyncImageLoader result;
81728
81729   {
81730     try {
81731       result = Dali::Toolkit::AsyncImageLoader::New();
81732     } catch (std::out_of_range& e) {
81733       {
81734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81735       };
81736     } catch (std::exception& e) {
81737       {
81738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81739       };
81740     } catch (...) {
81741       {
81742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81743       };
81744     }
81745   }
81746   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81747   return jresult;
81748 }
81749
81750
81751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
81752   void * jresult ;
81753   Dali::BaseHandle arg1 ;
81754   Dali::BaseHandle *argp1 ;
81755   Dali::Toolkit::AsyncImageLoader result;
81756
81757   argp1 = (Dali::BaseHandle *)jarg1;
81758   if (!argp1) {
81759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81760     return 0;
81761   }
81762   arg1 = *argp1;
81763   {
81764     try {
81765       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
81766     } catch (std::out_of_range& e) {
81767       {
81768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81769       };
81770     } catch (std::exception& e) {
81771       {
81772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81773       };
81774     } catch (...) {
81775       {
81776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81777       };
81778     }
81779   }
81780   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
81781   return jresult;
81782 }
81783
81784
81785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
81786   unsigned int jresult ;
81787   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81788   std::string *arg2 = 0 ;
81789   uint32_t result;
81790
81791   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81792   if (!jarg2) {
81793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81794     return 0;
81795   }
81796   std::string arg2_str(jarg2);
81797   arg2 = &arg2_str;
81798   {
81799     try {
81800       result = (arg1)->Load((std::string const &)*arg2);
81801     } catch (std::out_of_range& e) {
81802       {
81803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81804       };
81805     } catch (std::exception& e) {
81806       {
81807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81808       };
81809     } catch (...) {
81810       {
81811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81812       };
81813     }
81814   }
81815   jresult = result;
81816
81817   //argout typemap for const std::string&
81818
81819   return jresult;
81820 }
81821
81822
81823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
81824   unsigned int jresult ;
81825   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81826   std::string *arg2 = 0 ;
81827   Dali::ImageDimensions arg3 ;
81828   Dali::ImageDimensions *argp3 ;
81829   uint32_t result;
81830
81831   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81832   if (!jarg2) {
81833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81834     return 0;
81835   }
81836   std::string arg2_str(jarg2);
81837   arg2 = &arg2_str;
81838   argp3 = (Dali::ImageDimensions *)jarg3;
81839   if (!argp3) {
81840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81841     return 0;
81842   }
81843   arg3 = *argp3;
81844   {
81845     try {
81846       result = (arg1)->Load((std::string const &)*arg2,arg3);
81847     } catch (std::out_of_range& e) {
81848       {
81849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81850       };
81851     } catch (std::exception& e) {
81852       {
81853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81854       };
81855     } catch (...) {
81856       {
81857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81858       };
81859     }
81860   }
81861   jresult = result;
81862
81863   //argout typemap for const std::string&
81864
81865   return jresult;
81866 }
81867
81868
81869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
81870   unsigned int jresult ;
81871   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81872   std::string *arg2 = 0 ;
81873   Dali::ImageDimensions arg3 ;
81874   Dali::FittingMode::Type arg4 ;
81875   Dali::SamplingMode::Type arg5 ;
81876   bool arg6 ;
81877   Dali::ImageDimensions *argp3 ;
81878   uint32_t result;
81879
81880   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81881   if (!jarg2) {
81882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81883     return 0;
81884   }
81885   std::string arg2_str(jarg2);
81886   arg2 = &arg2_str;
81887   argp3 = (Dali::ImageDimensions *)jarg3;
81888   if (!argp3) {
81889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
81890     return 0;
81891   }
81892   arg3 = *argp3;
81893   arg4 = (Dali::FittingMode::Type)jarg4;
81894   arg5 = (Dali::SamplingMode::Type)jarg5;
81895   arg6 = jarg6 ? true : false;
81896   {
81897     try {
81898       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
81899     } catch (std::out_of_range& e) {
81900       {
81901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81902       };
81903     } catch (std::exception& e) {
81904       {
81905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81906       };
81907     } catch (...) {
81908       {
81909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81910       };
81911     }
81912   }
81913   jresult = result;
81914
81915   //argout typemap for const std::string&
81916
81917   return jresult;
81918 }
81919
81920
81921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
81922   unsigned int jresult ;
81923   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81924   uint32_t arg2 ;
81925   bool result;
81926
81927   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81928   arg2 = (uint32_t)jarg2;
81929   {
81930     try {
81931       result = (bool)(arg1)->Cancel(arg2);
81932     } catch (std::out_of_range& e) {
81933       {
81934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81935       };
81936     } catch (std::exception& e) {
81937       {
81938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81939       };
81940     } catch (...) {
81941       {
81942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81943       };
81944     }
81945   }
81946   jresult = result;
81947   return jresult;
81948 }
81949
81950
81951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
81952   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81953
81954   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81955   {
81956     try {
81957       (arg1)->CancelAll();
81958     } catch (std::out_of_range& e) {
81959       {
81960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81961       };
81962     } catch (std::exception& e) {
81963       {
81964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81965       };
81966     } catch (...) {
81967       {
81968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81969       };
81970     }
81971   }
81972 }
81973
81974
81975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
81976   void * jresult ;
81977   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
81978   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
81979
81980   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
81981   {
81982     try {
81983       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
81984     } catch (std::out_of_range& e) {
81985       {
81986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81987       };
81988     } catch (std::exception& e) {
81989       {
81990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81991       };
81992     } catch (...) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81995       };
81996     }
81997   }
81998   jresult = (void *)result;
81999   return jresult;
82000 }
82001
82002
82003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
82004   void * jresult ;
82005   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
82006   Dali::Toolkit::AsyncImageLoader *result = 0 ;
82007
82008   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
82009   {
82010     try {
82011       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
82012     } catch (std::out_of_range& e) {
82013       {
82014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82015       };
82016     } catch (std::exception& e) {
82017       {
82018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82019       };
82020     } catch (...) {
82021       {
82022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82023       };
82024     }
82025   }
82026   jresult = (void *)result;
82027   return jresult;
82028 }
82029
82030
82031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
82032   void * jresult ;
82033   std::string *arg1 = 0 ;
82034   Dali::PixelData result;
82035
82036   if (!jarg1) {
82037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82038     return 0;
82039   }
82040   std::string arg1_str(jarg1);
82041   arg1 = &arg1_str;
82042   {
82043     try {
82044       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
82045     } catch (std::out_of_range& e) {
82046       {
82047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82048       };
82049     } catch (std::exception& e) {
82050       {
82051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82052       };
82053     } catch (...) {
82054       {
82055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82056       };
82057     }
82058   }
82059   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82060
82061   //argout typemap for const std::string&
82062
82063   return jresult;
82064 }
82065
82066
82067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
82068   void * jresult ;
82069   std::string *arg1 = 0 ;
82070   Dali::ImageDimensions arg2 ;
82071   Dali::ImageDimensions *argp2 ;
82072   Dali::PixelData result;
82073
82074   if (!jarg1) {
82075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82076     return 0;
82077   }
82078   std::string arg1_str(jarg1);
82079   arg1 = &arg1_str;
82080   argp2 = (Dali::ImageDimensions *)jarg2;
82081   if (!argp2) {
82082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
82083     return 0;
82084   }
82085   arg2 = *argp2;
82086   {
82087     try {
82088       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
82089     } catch (std::out_of_range& e) {
82090       {
82091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82092       };
82093     } catch (std::exception& e) {
82094       {
82095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82096       };
82097     } catch (...) {
82098       {
82099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82100       };
82101     }
82102   }
82103   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82104
82105   //argout typemap for const std::string&
82106
82107   return jresult;
82108 }
82109
82110
82111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
82112   void * jresult ;
82113   std::string *arg1 = 0 ;
82114   Dali::ImageDimensions arg2 ;
82115   Dali::FittingMode::Type arg3 ;
82116   Dali::SamplingMode::Type arg4 ;
82117   bool arg5 ;
82118   Dali::ImageDimensions *argp2 ;
82119   Dali::PixelData result;
82120
82121   if (!jarg1) {
82122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82123     return 0;
82124   }
82125   std::string arg1_str(jarg1);
82126   arg1 = &arg1_str;
82127   argp2 = (Dali::ImageDimensions *)jarg2;
82128   if (!argp2) {
82129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
82130     return 0;
82131   }
82132   arg2 = *argp2;
82133   arg3 = (Dali::FittingMode::Type)jarg3;
82134   arg4 = (Dali::SamplingMode::Type)jarg4;
82135   arg5 = jarg5 ? true : false;
82136   {
82137     try {
82138       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
82139     } catch (std::out_of_range& e) {
82140       {
82141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82142       };
82143     } catch (std::exception& e) {
82144       {
82145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82146       };
82147     } catch (...) {
82148       {
82149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82150       };
82151     }
82152   }
82153   jresult = new Dali::PixelData((const Dali::PixelData &)result);
82154
82155   //argout typemap for const std::string&
82156
82157   return jresult;
82158 }
82159
82160
82161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
82162   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82163
82164   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82165   {
82166     try {
82167       delete arg1;
82168     } catch (std::out_of_range& e) {
82169       {
82170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82171       };
82172     } catch (std::exception& e) {
82173       {
82174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82175       };
82176     } catch (...) {
82177       {
82178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82179       };
82180     }
82181   }
82182 }
82183
82184
82185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
82186   void * jresult ;
82187   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
82188   Dali::Actor arg2 ;
82189   Dali::Actor arg3 ;
82190   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
82191   Dali::Actor *argp2 ;
82192   Dali::Actor *argp3 ;
82193   Dali::Actor result;
82194
82195   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
82196   argp2 = (Dali::Actor *)jarg2;
82197   if (!argp2) {
82198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82199     return 0;
82200   }
82201   arg2 = *argp2;
82202   argp3 = (Dali::Actor *)jarg3;
82203   if (!argp3) {
82204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82205     return 0;
82206   }
82207   arg3 = *argp3;
82208   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
82209   {
82210     try {
82211       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
82212     } catch (std::out_of_range& e) {
82213       {
82214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82215       };
82216     } catch (std::exception& e) {
82217       {
82218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82219       };
82220     } catch (...) {
82221       {
82222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82223       };
82224     }
82225   }
82226   jresult = new Dali::Actor((const Dali::Actor &)result);
82227   return jresult;
82228 }
82229
82230
82231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
82232   void * jresult ;
82233   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
82234
82235   {
82236     try {
82237       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
82238     } catch (std::out_of_range& e) {
82239       {
82240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82241       };
82242     } catch (std::exception& e) {
82243       {
82244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82245       };
82246     } catch (...) {
82247       {
82248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82249       };
82250     }
82251   }
82252   jresult = (void *)result;
82253   return jresult;
82254 }
82255
82256
82257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
82258   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
82259   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
82260   if (director) {
82261     director->swig_connect_director(callback0);
82262   }
82263 }
82264
82265
82266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
82267   KeyboardFocusManager arg1 ;
82268   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
82269   KeyboardFocusManager *argp1 ;
82270
82271   argp1 = (KeyboardFocusManager *)jarg1;
82272   if (!argp1) {
82273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
82274     return ;
82275   }
82276   arg1 = *argp1;
82277   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
82278   if (!arg2) {
82279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
82280     return ;
82281   }
82282   {
82283     try {
82284       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
82285     } catch (std::out_of_range& e) {
82286       {
82287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82288       };
82289     } catch (std::exception& e) {
82290       {
82291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82292       };
82293     } catch (...) {
82294       {
82295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82296       };
82297     }
82298   }
82299 }
82300
82301
82302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
82303   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82304
82305   arg1 = (std::vector< unsigned int > *)jarg1;
82306   {
82307     try {
82308       (arg1)->clear();
82309     } catch (std::out_of_range& e) {
82310       {
82311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82312       };
82313     } catch (std::exception& e) {
82314       {
82315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82316       };
82317     } catch (...) {
82318       {
82319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82320       };
82321     }
82322   }
82323 }
82324
82325
82326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
82327   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82328   unsigned int *arg2 = 0 ;
82329   unsigned int temp2 ;
82330
82331   arg1 = (std::vector< unsigned int > *)jarg1;
82332   temp2 = (unsigned int)jarg2;
82333   arg2 = &temp2;
82334   {
82335     try {
82336       (arg1)->push_back((unsigned int const &)*arg2);
82337     } catch (std::out_of_range& e) {
82338       {
82339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82340       };
82341     } catch (std::exception& e) {
82342       {
82343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82348       };
82349     }
82350   }
82351 }
82352
82353
82354 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
82355   unsigned long jresult ;
82356   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82357   std::vector< unsigned int >::size_type result;
82358
82359   arg1 = (std::vector< unsigned int > *)jarg1;
82360   {
82361     try {
82362       result = ((std::vector< unsigned int > const *)arg1)->size();
82363     } catch (std::out_of_range& e) {
82364       {
82365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82366       };
82367     } catch (std::exception& e) {
82368       {
82369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (...) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82374       };
82375     }
82376   }
82377   jresult = (unsigned long)result;
82378   return jresult;
82379 }
82380
82381
82382 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
82383   unsigned long jresult ;
82384   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82385   std::vector< unsigned int >::size_type result;
82386
82387   arg1 = (std::vector< unsigned int > *)jarg1;
82388   {
82389     try {
82390       result = ((std::vector< unsigned int > const *)arg1)->capacity();
82391     } catch (std::out_of_range& e) {
82392       {
82393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82394       };
82395     } catch (std::exception& e) {
82396       {
82397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82398       };
82399     } catch (...) {
82400       {
82401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82402       };
82403     }
82404   }
82405   jresult = (unsigned long)result;
82406   return jresult;
82407 }
82408
82409
82410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
82411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82412   std::vector< unsigned int >::size_type arg2 ;
82413
82414   arg1 = (std::vector< unsigned int > *)jarg1;
82415   arg2 = (std::vector< unsigned int >::size_type)jarg2;
82416   {
82417     try {
82418       (arg1)->reserve(arg2);
82419     } catch (std::out_of_range& e) {
82420       {
82421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82422       };
82423     } catch (std::exception& e) {
82424       {
82425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82426       };
82427     } catch (...) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82430       };
82431     }
82432   }
82433 }
82434
82435
82436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
82437   void * jresult ;
82438   std::vector< unsigned int > *result = 0 ;
82439
82440   {
82441     try {
82442       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
82443     } catch (std::out_of_range& e) {
82444       {
82445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82446       };
82447     } catch (std::exception& e) {
82448       {
82449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82450       };
82451     } catch (...) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82454       };
82455     }
82456   }
82457   jresult = (void *)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
82463   void * jresult ;
82464   std::vector< unsigned int > *arg1 = 0 ;
82465   std::vector< unsigned int > *result = 0 ;
82466
82467   arg1 = (std::vector< unsigned int > *)jarg1;
82468   if (!arg1) {
82469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82470     return 0;
82471   }
82472   {
82473     try {
82474       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
82475     } catch (std::out_of_range& e) {
82476       {
82477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82478       };
82479     } catch (std::exception& e) {
82480       {
82481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82482       };
82483     } catch (...) {
82484       {
82485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82486       };
82487     }
82488   }
82489   jresult = (void *)result;
82490   return jresult;
82491 }
82492
82493
82494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
82495   void * jresult ;
82496   int arg1 ;
82497   std::vector< unsigned int > *result = 0 ;
82498
82499   arg1 = (int)jarg1;
82500   {
82501     try {
82502       try {
82503         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
82504       }
82505       catch(std::out_of_range &_e) {
82506         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82507         return 0;
82508       }
82509
82510     } catch (std::out_of_range& e) {
82511       {
82512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82513       };
82514     } catch (std::exception& e) {
82515       {
82516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82517       };
82518     } catch (...) {
82519       {
82520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82521       };
82522     }
82523   }
82524   jresult = (void *)result;
82525   return jresult;
82526 }
82527
82528
82529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
82530   unsigned int jresult ;
82531   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82532   int arg2 ;
82533   unsigned int result;
82534
82535   arg1 = (std::vector< unsigned int > *)jarg1;
82536   arg2 = (int)jarg2;
82537   {
82538     try {
82539       try {
82540         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
82541       }
82542       catch(std::out_of_range &_e) {
82543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82544         return 0;
82545       }
82546
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561   jresult = result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
82567   unsigned int jresult ;
82568   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82569   int arg2 ;
82570   unsigned int *result = 0 ;
82571
82572   arg1 = (std::vector< unsigned int > *)jarg1;
82573   arg2 = (int)jarg2;
82574   {
82575     try {
82576       try {
82577         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
82578       }
82579       catch(std::out_of_range &_e) {
82580         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82581         return 0;
82582       }
82583
82584     } catch (std::out_of_range& e) {
82585       {
82586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82587       };
82588     } catch (std::exception& e) {
82589       {
82590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82591       };
82592     } catch (...) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82595       };
82596     }
82597   }
82598   jresult = *result;
82599   return jresult;
82600 }
82601
82602
82603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
82604   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82605   int arg2 ;
82606   unsigned int *arg3 = 0 ;
82607   unsigned int temp3 ;
82608
82609   arg1 = (std::vector< unsigned int > *)jarg1;
82610   arg2 = (int)jarg2;
82611   temp3 = (unsigned int)jarg3;
82612   arg3 = &temp3;
82613   {
82614     try {
82615       try {
82616         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
82617       }
82618       catch(std::out_of_range &_e) {
82619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82620         return ;
82621       }
82622
82623     } catch (std::out_of_range& e) {
82624       {
82625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82626       };
82627     } catch (std::exception& e) {
82628       {
82629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82630       };
82631     } catch (...) {
82632       {
82633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82634       };
82635     }
82636   }
82637 }
82638
82639
82640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
82641   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82642   std::vector< unsigned int > *arg2 = 0 ;
82643
82644   arg1 = (std::vector< unsigned int > *)jarg1;
82645   arg2 = (std::vector< unsigned int > *)jarg2;
82646   if (!arg2) {
82647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82648     return ;
82649   }
82650   {
82651     try {
82652       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
82653     } catch (std::out_of_range& e) {
82654       {
82655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82656       };
82657     } catch (std::exception& e) {
82658       {
82659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82660       };
82661     } catch (...) {
82662       {
82663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82664       };
82665     }
82666   }
82667 }
82668
82669
82670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
82671   void * jresult ;
82672   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82673   int arg2 ;
82674   int arg3 ;
82675   std::vector< unsigned int > *result = 0 ;
82676
82677   arg1 = (std::vector< unsigned int > *)jarg1;
82678   arg2 = (int)jarg2;
82679   arg3 = (int)jarg3;
82680   {
82681     try {
82682       try {
82683         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
82684       }
82685       catch(std::out_of_range &_e) {
82686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82687         return 0;
82688       }
82689       catch(std::invalid_argument &_e) {
82690         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82691         return 0;
82692       }
82693
82694     } catch (std::out_of_range& e) {
82695       {
82696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82697       };
82698     } catch (std::exception& e) {
82699       {
82700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82701       };
82702     } catch (...) {
82703       {
82704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82705       };
82706     }
82707   }
82708   jresult = (void *)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
82714   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82715   int arg2 ;
82716   unsigned int *arg3 = 0 ;
82717   unsigned int temp3 ;
82718
82719   arg1 = (std::vector< unsigned int > *)jarg1;
82720   arg2 = (int)jarg2;
82721   temp3 = (unsigned int)jarg3;
82722   arg3 = &temp3;
82723   {
82724     try {
82725       try {
82726         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
82727       }
82728       catch(std::out_of_range &_e) {
82729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82730         return ;
82731       }
82732
82733     } catch (std::out_of_range& e) {
82734       {
82735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82736       };
82737     } catch (std::exception& e) {
82738       {
82739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82740       };
82741     } catch (...) {
82742       {
82743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82744       };
82745     }
82746   }
82747 }
82748
82749
82750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
82751   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82752   int arg2 ;
82753   std::vector< unsigned int > *arg3 = 0 ;
82754
82755   arg1 = (std::vector< unsigned int > *)jarg1;
82756   arg2 = (int)jarg2;
82757   arg3 = (std::vector< unsigned int > *)jarg3;
82758   if (!arg3) {
82759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82760     return ;
82761   }
82762   {
82763     try {
82764       try {
82765         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82766       }
82767       catch(std::out_of_range &_e) {
82768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82769         return ;
82770       }
82771
82772     } catch (std::out_of_range& e) {
82773       {
82774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82775       };
82776     } catch (std::exception& e) {
82777       {
82778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82779       };
82780     } catch (...) {
82781       {
82782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82783       };
82784     }
82785   }
82786 }
82787
82788
82789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
82790   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82791   int arg2 ;
82792
82793   arg1 = (std::vector< unsigned int > *)jarg1;
82794   arg2 = (int)jarg2;
82795   {
82796     try {
82797       try {
82798         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
82799       }
82800       catch(std::out_of_range &_e) {
82801         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82802         return ;
82803       }
82804
82805     } catch (std::out_of_range& e) {
82806       {
82807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82808       };
82809     } catch (std::exception& e) {
82810       {
82811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82812       };
82813     } catch (...) {
82814       {
82815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82816       };
82817     }
82818   }
82819 }
82820
82821
82822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
82823   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82824   int arg2 ;
82825   int arg3 ;
82826
82827   arg1 = (std::vector< unsigned int > *)jarg1;
82828   arg2 = (int)jarg2;
82829   arg3 = (int)jarg3;
82830   {
82831     try {
82832       try {
82833         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
82834       }
82835       catch(std::out_of_range &_e) {
82836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82837         return ;
82838       }
82839       catch(std::invalid_argument &_e) {
82840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82841         return ;
82842       }
82843
82844     } catch (std::out_of_range& e) {
82845       {
82846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82847       };
82848     } catch (std::exception& e) {
82849       {
82850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82851       };
82852     } catch (...) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82855       };
82856     }
82857   }
82858 }
82859
82860
82861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
82862   void * jresult ;
82863   unsigned int *arg1 = 0 ;
82864   int arg2 ;
82865   unsigned int temp1 ;
82866   std::vector< unsigned int > *result = 0 ;
82867
82868   temp1 = (unsigned int)jarg1;
82869   arg1 = &temp1;
82870   arg2 = (int)jarg2;
82871   {
82872     try {
82873       try {
82874         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
82875       }
82876       catch(std::out_of_range &_e) {
82877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82878         return 0;
82879       }
82880
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (...) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82892       };
82893     }
82894   }
82895   jresult = (void *)result;
82896   return jresult;
82897 }
82898
82899
82900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
82901   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82902
82903   arg1 = (std::vector< unsigned int > *)jarg1;
82904   {
82905     try {
82906       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
82907     } catch (std::out_of_range& e) {
82908       {
82909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82910       };
82911     } catch (std::exception& e) {
82912       {
82913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82914       };
82915     } catch (...) {
82916       {
82917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82918       };
82919     }
82920   }
82921 }
82922
82923
82924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
82925   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82926   int arg2 ;
82927   int arg3 ;
82928
82929   arg1 = (std::vector< unsigned int > *)jarg1;
82930   arg2 = (int)jarg2;
82931   arg3 = (int)jarg3;
82932   {
82933     try {
82934       try {
82935         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
82936       }
82937       catch(std::out_of_range &_e) {
82938         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82939         return ;
82940       }
82941       catch(std::invalid_argument &_e) {
82942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
82943         return ;
82944       }
82945
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82953       };
82954     } catch (...) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82957       };
82958     }
82959   }
82960 }
82961
82962
82963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
82964   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
82965   int arg2 ;
82966   std::vector< unsigned int > *arg3 = 0 ;
82967
82968   arg1 = (std::vector< unsigned int > *)jarg1;
82969   arg2 = (int)jarg2;
82970   arg3 = (std::vector< unsigned int > *)jarg3;
82971   if (!arg3) {
82972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
82973     return ;
82974   }
82975   {
82976     try {
82977       try {
82978         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
82979       }
82980       catch(std::out_of_range &_e) {
82981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
82982         return ;
82983       }
82984
82985     } catch (std::out_of_range& e) {
82986       {
82987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82988       };
82989     } catch (std::exception& e) {
82990       {
82991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82992       };
82993     } catch (...) {
82994       {
82995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82996       };
82997     }
82998   }
82999 }
83000
83001
83002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
83003   unsigned int jresult ;
83004   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83005   unsigned int *arg2 = 0 ;
83006   unsigned int temp2 ;
83007   bool result;
83008
83009   arg1 = (std::vector< unsigned int > *)jarg1;
83010   temp2 = (unsigned int)jarg2;
83011   arg2 = &temp2;
83012   {
83013     try {
83014       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
83015     } catch (std::out_of_range& e) {
83016       {
83017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83018       };
83019     } catch (std::exception& e) {
83020       {
83021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83022       };
83023     } catch (...) {
83024       {
83025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83026       };
83027     }
83028   }
83029   jresult = result;
83030   return jresult;
83031 }
83032
83033
83034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
83035   int jresult ;
83036   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83037   unsigned int *arg2 = 0 ;
83038   unsigned int temp2 ;
83039   int result;
83040
83041   arg1 = (std::vector< unsigned int > *)jarg1;
83042   temp2 = (unsigned int)jarg2;
83043   arg2 = &temp2;
83044   {
83045     try {
83046       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
83047     } catch (std::out_of_range& e) {
83048       {
83049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83050       };
83051     } catch (std::exception& e) {
83052       {
83053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83054       };
83055     } catch (...) {
83056       {
83057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83058       };
83059     }
83060   }
83061   jresult = result;
83062   return jresult;
83063 }
83064
83065
83066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
83067   int jresult ;
83068   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83069   unsigned int *arg2 = 0 ;
83070   unsigned int temp2 ;
83071   int result;
83072
83073   arg1 = (std::vector< unsigned int > *)jarg1;
83074   temp2 = (unsigned int)jarg2;
83075   arg2 = &temp2;
83076   {
83077     try {
83078       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
83079     } catch (std::out_of_range& e) {
83080       {
83081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83082       };
83083     } catch (std::exception& e) {
83084       {
83085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83086       };
83087     } catch (...) {
83088       {
83089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83090       };
83091     }
83092   }
83093   jresult = result;
83094   return jresult;
83095 }
83096
83097
83098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
83099   unsigned int jresult ;
83100   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83101   unsigned int *arg2 = 0 ;
83102   unsigned int temp2 ;
83103   bool result;
83104
83105   arg1 = (std::vector< unsigned int > *)jarg1;
83106   temp2 = (unsigned int)jarg2;
83107   arg2 = &temp2;
83108   {
83109     try {
83110       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
83111     } catch (std::out_of_range& e) {
83112       {
83113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83114       };
83115     } catch (std::exception& e) {
83116       {
83117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83118       };
83119     } catch (...) {
83120       {
83121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83122       };
83123     }
83124   }
83125   jresult = result;
83126   return jresult;
83127 }
83128
83129
83130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
83131   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
83132
83133   arg1 = (std::vector< unsigned int > *)jarg1;
83134   {
83135     try {
83136       delete arg1;
83137     } catch (std::out_of_range& e) {
83138       {
83139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83140       };
83141     } catch (std::exception& e) {
83142       {
83143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83144       };
83145     } catch (...) {
83146       {
83147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83148       };
83149     }
83150   }
83151 }
83152
83153
83154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
83155   void * jresult ;
83156   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83157
83158   {
83159     try {
83160       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
83161     } catch (std::out_of_range& e) {
83162       {
83163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (std::exception& e) {
83166       {
83167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (...) {
83170       {
83171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83172       };
83173     }
83174   }
83175   jresult = (void *)result;
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
83181   void * jresult ;
83182   unsigned int arg1 ;
83183   Dali::Actor arg2 ;
83184   Dali::Actor *argp2 ;
83185   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83186
83187   arg1 = (unsigned int)jarg1;
83188   argp2 = (Dali::Actor *)jarg2;
83189   if (!argp2) {
83190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83191     return 0;
83192   }
83193   arg2 = *argp2;
83194   {
83195     try {
83196       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
83197     } catch (std::out_of_range& e) {
83198       {
83199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83200       };
83201     } catch (std::exception& e) {
83202       {
83203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83204       };
83205     } catch (...) {
83206       {
83207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83208       };
83209     }
83210   }
83211   jresult = (void *)result;
83212   return jresult;
83213 }
83214
83215
83216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
83217   void * jresult ;
83218   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83219   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83220
83221   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83222   if (!arg1) {
83223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83224     return 0;
83225   }
83226   {
83227     try {
83228       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
83229     } catch (std::out_of_range& e) {
83230       {
83231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83232       };
83233     } catch (std::exception& e) {
83234       {
83235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (...) {
83238       {
83239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83240       };
83241     }
83242   }
83243   jresult = (void *)result;
83244   return jresult;
83245 }
83246
83247
83248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
83249   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83250   unsigned int arg2 ;
83251
83252   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83253   arg2 = (unsigned int)jarg2;
83254   if (arg1) (arg1)->first = arg2;
83255 }
83256
83257
83258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
83259   unsigned int jresult ;
83260   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83261   unsigned int result;
83262
83263   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83264   result = (unsigned int) ((arg1)->first);
83265   jresult = result;
83266   return jresult;
83267 }
83268
83269
83270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
83271   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83272   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
83273
83274   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83275   arg2 = (Dali::Actor *)jarg2;
83276   if (arg1) (arg1)->second = *arg2;
83277 }
83278
83279
83280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
83281   void * jresult ;
83282   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83283   Dali::Actor *result = 0 ;
83284
83285   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83286   result = (Dali::Actor *)& ((arg1)->second);
83287   jresult = (void *)result;
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
83293   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
83294
83295   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83296   {
83297     try {
83298       delete arg1;
83299     } catch (std::out_of_range& e) {
83300       {
83301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83302       };
83303     } catch (std::exception& e) {
83304       {
83305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83306       };
83307     } catch (...) {
83308       {
83309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83310       };
83311     }
83312   }
83313 }
83314
83315
83316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
83317   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83318
83319   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83320   {
83321     try {
83322       (arg1)->clear();
83323     } catch (std::out_of_range& e) {
83324       {
83325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83326       };
83327     } catch (std::exception& e) {
83328       {
83329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83330       };
83331     } catch (...) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83334       };
83335     }
83336   }
83337 }
83338
83339
83340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
83341   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83342   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
83343
83344   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83345   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
83346   if (!arg2) {
83347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83348     return ;
83349   }
83350   {
83351     try {
83352       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
83353     } catch (std::out_of_range& e) {
83354       {
83355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83356       };
83357     } catch (std::exception& e) {
83358       {
83359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83360       };
83361     } catch (...) {
83362       {
83363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83364       };
83365     }
83366   }
83367 }
83368
83369
83370 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
83371   unsigned long jresult ;
83372   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83373   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83374
83375   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83376   {
83377     try {
83378       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (...) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83390       };
83391     }
83392   }
83393   jresult = (unsigned long)result;
83394   return jresult;
83395 }
83396
83397
83398 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
83399   unsigned long jresult ;
83400   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83401   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
83402
83403   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83404   {
83405     try {
83406       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
83407     } catch (std::out_of_range& e) {
83408       {
83409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83410       };
83411     } catch (std::exception& e) {
83412       {
83413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83414       };
83415     } catch (...) {
83416       {
83417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83418       };
83419     }
83420   }
83421   jresult = (unsigned long)result;
83422   return jresult;
83423 }
83424
83425
83426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
83427   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83428   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
83429
83430   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83431   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
83432   {
83433     try {
83434       (arg1)->reserve(arg2);
83435     } catch (std::out_of_range& e) {
83436       {
83437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83438       };
83439     } catch (std::exception& e) {
83440       {
83441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83442       };
83443     } catch (...) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83446       };
83447     }
83448   }
83449 }
83450
83451
83452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
83453   void * jresult ;
83454   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83455
83456   {
83457     try {
83458       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
83459     } catch (std::out_of_range& e) {
83460       {
83461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83462       };
83463     } catch (std::exception& e) {
83464       {
83465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83466       };
83467     } catch (...) {
83468       {
83469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83470       };
83471     }
83472   }
83473   jresult = (void *)result;
83474   return jresult;
83475 }
83476
83477
83478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
83479   void * jresult ;
83480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
83481   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83482
83483   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83484   if (!arg1) {
83485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83486     return 0;
83487   }
83488   {
83489     try {
83490       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);
83491     } catch (std::out_of_range& e) {
83492       {
83493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (std::exception& e) {
83496       {
83497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83498       };
83499     } catch (...) {
83500       {
83501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83502       };
83503     }
83504   }
83505   jresult = (void *)result;
83506   return jresult;
83507 }
83508
83509
83510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
83511   void * jresult ;
83512   int arg1 ;
83513   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83514
83515   arg1 = (int)jarg1;
83516   {
83517     try {
83518       try {
83519         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);
83520       }
83521       catch(std::out_of_range &_e) {
83522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83523         return 0;
83524       }
83525
83526     } catch (std::out_of_range& e) {
83527       {
83528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83529       };
83530     } catch (std::exception& e) {
83531       {
83532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83533       };
83534     } catch (...) {
83535       {
83536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83537       };
83538     }
83539   }
83540   jresult = (void *)result;
83541   return jresult;
83542 }
83543
83544
83545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
83546   void * jresult ;
83547   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83548   int arg2 ;
83549   std::pair< unsigned int,Dali::Actor > result;
83550
83551   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83552   arg2 = (int)jarg2;
83553   {
83554     try {
83555       try {
83556         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
83557       }
83558       catch(std::out_of_range &_e) {
83559         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83560         return 0;
83561       }
83562
83563     } catch (std::out_of_range& e) {
83564       {
83565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83566       };
83567     } catch (std::exception& e) {
83568       {
83569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83570       };
83571     } catch (...) {
83572       {
83573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83574       };
83575     }
83576   }
83577   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
83578   return jresult;
83579 }
83580
83581
83582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
83583   void * jresult ;
83584   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83585   int arg2 ;
83586   std::pair< unsigned int,Dali::Actor > *result = 0 ;
83587
83588   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83589   arg2 = (int)jarg2;
83590   {
83591     try {
83592       try {
83593         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
83594       }
83595       catch(std::out_of_range &_e) {
83596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83597         return 0;
83598       }
83599
83600     } catch (std::out_of_range& e) {
83601       {
83602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83603       };
83604     } catch (std::exception& e) {
83605       {
83606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83607       };
83608     } catch (...) {
83609       {
83610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83611       };
83612     }
83613   }
83614   jresult = (void *)result;
83615   return jresult;
83616 }
83617
83618
83619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
83620   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83621   int arg2 ;
83622   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83623
83624   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83625   arg2 = (int)jarg2;
83626   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83627   if (!arg3) {
83628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83629     return ;
83630   }
83631   {
83632     try {
83633       try {
83634         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);
83635       }
83636       catch(std::out_of_range &_e) {
83637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83638         return ;
83639       }
83640
83641     } catch (std::out_of_range& e) {
83642       {
83643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83644       };
83645     } catch (std::exception& e) {
83646       {
83647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83648       };
83649     } catch (...) {
83650       {
83651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83652       };
83653     }
83654   }
83655 }
83656
83657
83658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
83659   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83660   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
83661
83662   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83663   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
83664   if (!arg2) {
83665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83666     return ;
83667   }
83668   {
83669     try {
83670       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);
83671     } catch (std::out_of_range& e) {
83672       {
83673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83674       };
83675     } catch (std::exception& e) {
83676       {
83677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83678       };
83679     } catch (...) {
83680       {
83681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83682       };
83683     }
83684   }
83685 }
83686
83687
83688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
83689   void * jresult ;
83690   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83691   int arg2 ;
83692   int arg3 ;
83693   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83694
83695   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83696   arg2 = (int)jarg2;
83697   arg3 = (int)jarg3;
83698   {
83699     try {
83700       try {
83701         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);
83702       }
83703       catch(std::out_of_range &_e) {
83704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83705         return 0;
83706       }
83707       catch(std::invalid_argument &_e) {
83708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83709         return 0;
83710       }
83711
83712     } catch (std::out_of_range& e) {
83713       {
83714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83715       };
83716     } catch (std::exception& e) {
83717       {
83718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83719       };
83720     } catch (...) {
83721       {
83722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83723       };
83724     }
83725   }
83726   jresult = (void *)result;
83727   return jresult;
83728 }
83729
83730
83731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
83732   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83733   int arg2 ;
83734   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
83735
83736   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83737   arg2 = (int)jarg2;
83738   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
83739   if (!arg3) {
83740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83741     return ;
83742   }
83743   {
83744     try {
83745       try {
83746         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);
83747       }
83748       catch(std::out_of_range &_e) {
83749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83750         return ;
83751       }
83752
83753     } catch (std::out_of_range& e) {
83754       {
83755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83756       };
83757     } catch (std::exception& e) {
83758       {
83759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83760       };
83761     } catch (...) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83764       };
83765     }
83766   }
83767 }
83768
83769
83770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
83771   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83772   int arg2 ;
83773   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83774
83775   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83776   arg2 = (int)jarg2;
83777   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83778   if (!arg3) {
83779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83780     return ;
83781   }
83782   {
83783     try {
83784       try {
83785         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);
83786       }
83787       catch(std::out_of_range &_e) {
83788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83789         return ;
83790       }
83791
83792     } catch (std::out_of_range& e) {
83793       {
83794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83795       };
83796     } catch (std::exception& e) {
83797       {
83798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83799       };
83800     } catch (...) {
83801       {
83802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83803       };
83804     }
83805   }
83806 }
83807
83808
83809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
83810   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83811   int arg2 ;
83812
83813   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83814   arg2 = (int)jarg2;
83815   {
83816     try {
83817       try {
83818         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
83819       }
83820       catch(std::out_of_range &_e) {
83821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83822         return ;
83823       }
83824
83825     } catch (std::out_of_range& e) {
83826       {
83827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (std::exception& e) {
83830       {
83831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83832       };
83833     } catch (...) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83836       };
83837     }
83838   }
83839 }
83840
83841
83842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
83843   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83844   int arg2 ;
83845   int arg3 ;
83846
83847   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83848   arg2 = (int)jarg2;
83849   arg3 = (int)jarg3;
83850   {
83851     try {
83852       try {
83853         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
83854       }
83855       catch(std::out_of_range &_e) {
83856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83857         return ;
83858       }
83859       catch(std::invalid_argument &_e) {
83860         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83861         return ;
83862       }
83863
83864     } catch (std::out_of_range& e) {
83865       {
83866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83867       };
83868     } catch (std::exception& e) {
83869       {
83870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83871       };
83872     } catch (...) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83875       };
83876     }
83877   }
83878 }
83879
83880
83881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
83882   void * jresult ;
83883   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
83884   int arg2 ;
83885   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
83886
83887   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
83888   if (!arg1) {
83889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
83890     return 0;
83891   }
83892   arg2 = (int)jarg2;
83893   {
83894     try {
83895       try {
83896         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);
83897       }
83898       catch(std::out_of_range &_e) {
83899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83900         return 0;
83901       }
83902
83903     } catch (std::out_of_range& e) {
83904       {
83905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83906       };
83907     } catch (std::exception& e) {
83908       {
83909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83910       };
83911     } catch (...) {
83912       {
83913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83914       };
83915     }
83916   }
83917   jresult = (void *)result;
83918   return jresult;
83919 }
83920
83921
83922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
83923   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83924
83925   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83926   {
83927     try {
83928       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
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_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
83947   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83948   int arg2 ;
83949   int arg3 ;
83950
83951   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83952   arg2 = (int)jarg2;
83953   arg3 = (int)jarg3;
83954   {
83955     try {
83956       try {
83957         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
83958       }
83959       catch(std::out_of_range &_e) {
83960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
83961         return ;
83962       }
83963       catch(std::invalid_argument &_e) {
83964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
83965         return ;
83966       }
83967
83968     } catch (std::out_of_range& e) {
83969       {
83970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83971       };
83972     } catch (std::exception& e) {
83973       {
83974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83975       };
83976     } catch (...) {
83977       {
83978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83979       };
83980     }
83981   }
83982 }
83983
83984
83985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
83986   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
83987   int arg2 ;
83988   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
83989
83990   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
83991   arg2 = (int)jarg2;
83992   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
83993   if (!arg3) {
83994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
83995     return ;
83996   }
83997   {
83998     try {
83999       try {
84000         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);
84001       }
84002       catch(std::out_of_range &_e) {
84003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84004         return ;
84005       }
84006
84007     } catch (std::out_of_range& e) {
84008       {
84009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84010       };
84011     } catch (std::exception& e) {
84012       {
84013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84014       };
84015     } catch (...) {
84016       {
84017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84018       };
84019     }
84020   }
84021 }
84022
84023
84024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
84025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
84026
84027   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
84028   {
84029     try {
84030       delete arg1;
84031     } catch (std::out_of_range& e) {
84032       {
84033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84034       };
84035     } catch (std::exception& e) {
84036       {
84037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84038       };
84039     } catch (...) {
84040       {
84041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84042       };
84043     }
84044   }
84045 }
84046
84047
84048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
84049   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84050
84051   arg1 = (std::vector< Dali::Actor > *)jarg1;
84052   {
84053     try {
84054       (arg1)->clear();
84055     } catch (std::out_of_range& e) {
84056       {
84057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (std::exception& e) {
84060       {
84061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069 }
84070
84071
84072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
84073   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84074   Dali::Actor *arg2 = 0 ;
84075
84076   arg1 = (std::vector< Dali::Actor > *)jarg1;
84077   arg2 = (Dali::Actor *)jarg2;
84078   if (!arg2) {
84079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84080     return ;
84081   }
84082   {
84083     try {
84084       (arg1)->push_back((Dali::Actor const &)*arg2);
84085     } catch (std::out_of_range& e) {
84086       {
84087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84088       };
84089     } catch (std::exception& e) {
84090       {
84091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84092       };
84093     } catch (...) {
84094       {
84095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84096       };
84097     }
84098   }
84099 }
84100
84101
84102 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
84103   unsigned long jresult ;
84104   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84105   std::vector< Dali::Actor >::size_type result;
84106
84107   arg1 = (std::vector< Dali::Actor > *)jarg1;
84108   {
84109     try {
84110       result = ((std::vector< Dali::Actor > const *)arg1)->size();
84111     } catch (std::out_of_range& e) {
84112       {
84113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84114       };
84115     } catch (std::exception& e) {
84116       {
84117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84118       };
84119     } catch (...) {
84120       {
84121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84122       };
84123     }
84124   }
84125   jresult = (unsigned long)result;
84126   return jresult;
84127 }
84128
84129
84130 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
84131   unsigned long jresult ;
84132   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84133   std::vector< Dali::Actor >::size_type result;
84134
84135   arg1 = (std::vector< Dali::Actor > *)jarg1;
84136   {
84137     try {
84138       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
84139     } catch (std::out_of_range& e) {
84140       {
84141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (std::exception& e) {
84144       {
84145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (...) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84150       };
84151     }
84152   }
84153   jresult = (unsigned long)result;
84154   return jresult;
84155 }
84156
84157
84158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
84159   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84160   std::vector< Dali::Actor >::size_type arg2 ;
84161
84162   arg1 = (std::vector< Dali::Actor > *)jarg1;
84163   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
84164   {
84165     try {
84166       (arg1)->reserve(arg2);
84167     } catch (std::out_of_range& e) {
84168       {
84169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84170       };
84171     } catch (std::exception& e) {
84172       {
84173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84174       };
84175     } catch (...) {
84176       {
84177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84178       };
84179     }
84180   }
84181 }
84182
84183
84184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
84185   void * jresult ;
84186   std::vector< Dali::Actor > *result = 0 ;
84187
84188   {
84189     try {
84190       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
84191     } catch (std::out_of_range& e) {
84192       {
84193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84194       };
84195     } catch (std::exception& e) {
84196       {
84197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84198       };
84199     } catch (...) {
84200       {
84201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84202       };
84203     }
84204   }
84205   jresult = (void *)result;
84206   return jresult;
84207 }
84208
84209
84210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
84211   void * jresult ;
84212   std::vector< Dali::Actor > *arg1 = 0 ;
84213   std::vector< Dali::Actor > *result = 0 ;
84214
84215   arg1 = (std::vector< Dali::Actor > *)jarg1;
84216   if (!arg1) {
84217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84218     return 0;
84219   }
84220   {
84221     try {
84222       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
84223     } catch (std::out_of_range& e) {
84224       {
84225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (std::exception& e) {
84228       {
84229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (...) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84234       };
84235     }
84236   }
84237   jresult = (void *)result;
84238   return jresult;
84239 }
84240
84241
84242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
84243   void * jresult ;
84244   int arg1 ;
84245   std::vector< Dali::Actor > *result = 0 ;
84246
84247   arg1 = (int)jarg1;
84248   {
84249     try {
84250       try {
84251         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
84252       }
84253       catch(std::out_of_range &_e) {
84254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84255         return 0;
84256       }
84257
84258     } catch (std::out_of_range& e) {
84259       {
84260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84261       };
84262     } catch (std::exception& e) {
84263       {
84264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84265       };
84266     } catch (...) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84269       };
84270     }
84271   }
84272   jresult = (void *)result;
84273   return jresult;
84274 }
84275
84276
84277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
84278   void * jresult ;
84279   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84280   int arg2 ;
84281   Dali::Actor result;
84282
84283   arg1 = (std::vector< Dali::Actor > *)jarg1;
84284   arg2 = (int)jarg2;
84285   {
84286     try {
84287       try {
84288         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
84289       }
84290       catch(std::out_of_range &_e) {
84291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84292         return 0;
84293       }
84294
84295     } catch (std::out_of_range& e) {
84296       {
84297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (std::exception& e) {
84300       {
84301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (...) {
84304       {
84305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84306       };
84307     }
84308   }
84309   jresult = new Dali::Actor((const Dali::Actor &)result);
84310   return jresult;
84311 }
84312
84313
84314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
84315   void * jresult ;
84316   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84317   int arg2 ;
84318   Dali::Actor *result = 0 ;
84319
84320   arg1 = (std::vector< Dali::Actor > *)jarg1;
84321   arg2 = (int)jarg2;
84322   {
84323     try {
84324       try {
84325         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
84326       }
84327       catch(std::out_of_range &_e) {
84328         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84329         return 0;
84330       }
84331
84332     } catch (std::out_of_range& e) {
84333       {
84334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84335       };
84336     } catch (std::exception& e) {
84337       {
84338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84339       };
84340     } catch (...) {
84341       {
84342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84343       };
84344     }
84345   }
84346   jresult = (void *)result;
84347   return jresult;
84348 }
84349
84350
84351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
84352   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84353   int arg2 ;
84354   Dali::Actor *arg3 = 0 ;
84355
84356   arg1 = (std::vector< Dali::Actor > *)jarg1;
84357   arg2 = (int)jarg2;
84358   arg3 = (Dali::Actor *)jarg3;
84359   if (!arg3) {
84360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84361     return ;
84362   }
84363   {
84364     try {
84365       try {
84366         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
84367       }
84368       catch(std::out_of_range &_e) {
84369         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84370         return ;
84371       }
84372
84373     } catch (std::out_of_range& e) {
84374       {
84375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84376       };
84377     } catch (std::exception& e) {
84378       {
84379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84380       };
84381     } catch (...) {
84382       {
84383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84384       };
84385     }
84386   }
84387 }
84388
84389
84390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
84391   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84392   std::vector< Dali::Actor > *arg2 = 0 ;
84393
84394   arg1 = (std::vector< Dali::Actor > *)jarg1;
84395   arg2 = (std::vector< Dali::Actor > *)jarg2;
84396   if (!arg2) {
84397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84398     return ;
84399   }
84400   {
84401     try {
84402       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
84403     } catch (std::out_of_range& e) {
84404       {
84405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84406       };
84407     } catch (std::exception& e) {
84408       {
84409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84410       };
84411     } catch (...) {
84412       {
84413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84414       };
84415     }
84416   }
84417 }
84418
84419
84420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
84421   void * jresult ;
84422   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84423   int arg2 ;
84424   int arg3 ;
84425   std::vector< Dali::Actor > *result = 0 ;
84426
84427   arg1 = (std::vector< Dali::Actor > *)jarg1;
84428   arg2 = (int)jarg2;
84429   arg3 = (int)jarg3;
84430   {
84431     try {
84432       try {
84433         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
84434       }
84435       catch(std::out_of_range &_e) {
84436         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84437         return 0;
84438       }
84439       catch(std::invalid_argument &_e) {
84440         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84441         return 0;
84442       }
84443
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84451       };
84452     } catch (...) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84455       };
84456     }
84457   }
84458   jresult = (void *)result;
84459   return jresult;
84460 }
84461
84462
84463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
84464   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84465   int arg2 ;
84466   Dali::Actor *arg3 = 0 ;
84467
84468   arg1 = (std::vector< Dali::Actor > *)jarg1;
84469   arg2 = (int)jarg2;
84470   arg3 = (Dali::Actor *)jarg3;
84471   if (!arg3) {
84472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84473     return ;
84474   }
84475   {
84476     try {
84477       try {
84478         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
84479       }
84480       catch(std::out_of_range &_e) {
84481         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84482         return ;
84483       }
84484
84485     } catch (std::out_of_range& e) {
84486       {
84487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84488       };
84489     } catch (std::exception& e) {
84490       {
84491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84492       };
84493     } catch (...) {
84494       {
84495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84496       };
84497     }
84498   }
84499 }
84500
84501
84502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
84503   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84504   int arg2 ;
84505   std::vector< Dali::Actor > *arg3 = 0 ;
84506
84507   arg1 = (std::vector< Dali::Actor > *)jarg1;
84508   arg2 = (int)jarg2;
84509   arg3 = (std::vector< Dali::Actor > *)jarg3;
84510   if (!arg3) {
84511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84512     return ;
84513   }
84514   {
84515     try {
84516       try {
84517         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84518       }
84519       catch(std::out_of_range &_e) {
84520         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84521         return ;
84522       }
84523
84524     } catch (std::out_of_range& e) {
84525       {
84526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84527       };
84528     } catch (std::exception& e) {
84529       {
84530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84531       };
84532     } catch (...) {
84533       {
84534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84535       };
84536     }
84537   }
84538 }
84539
84540
84541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
84542   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84543   int arg2 ;
84544
84545   arg1 = (std::vector< Dali::Actor > *)jarg1;
84546   arg2 = (int)jarg2;
84547   {
84548     try {
84549       try {
84550         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
84551       }
84552       catch(std::out_of_range &_e) {
84553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84554         return ;
84555       }
84556
84557     } catch (std::out_of_range& e) {
84558       {
84559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84560       };
84561     } catch (std::exception& e) {
84562       {
84563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84564       };
84565     } catch (...) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84568       };
84569     }
84570   }
84571 }
84572
84573
84574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
84575   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84576   int arg2 ;
84577   int arg3 ;
84578
84579   arg1 = (std::vector< Dali::Actor > *)jarg1;
84580   arg2 = (int)jarg2;
84581   arg3 = (int)jarg3;
84582   {
84583     try {
84584       try {
84585         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
84586       }
84587       catch(std::out_of_range &_e) {
84588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84589         return ;
84590       }
84591       catch(std::invalid_argument &_e) {
84592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84593         return ;
84594       }
84595
84596     } catch (std::out_of_range& e) {
84597       {
84598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84599       };
84600     } catch (std::exception& e) {
84601       {
84602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84603       };
84604     } catch (...) {
84605       {
84606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84607       };
84608     }
84609   }
84610 }
84611
84612
84613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
84614   void * jresult ;
84615   Dali::Actor *arg1 = 0 ;
84616   int arg2 ;
84617   std::vector< Dali::Actor > *result = 0 ;
84618
84619   arg1 = (Dali::Actor *)jarg1;
84620   if (!arg1) {
84621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
84622     return 0;
84623   }
84624   arg2 = (int)jarg2;
84625   {
84626     try {
84627       try {
84628         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
84629       }
84630       catch(std::out_of_range &_e) {
84631         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84632         return 0;
84633       }
84634
84635     } catch (std::out_of_range& e) {
84636       {
84637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84638       };
84639     } catch (std::exception& e) {
84640       {
84641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (...) {
84644       {
84645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84646       };
84647     }
84648   }
84649   jresult = (void *)result;
84650   return jresult;
84651 }
84652
84653
84654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
84655   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84656
84657   arg1 = (std::vector< Dali::Actor > *)jarg1;
84658   {
84659     try {
84660       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
84661     } catch (std::out_of_range& e) {
84662       {
84663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84664       };
84665     } catch (std::exception& e) {
84666       {
84667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84668       };
84669     } catch (...) {
84670       {
84671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84672       };
84673     }
84674   }
84675 }
84676
84677
84678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
84679   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84680   int arg2 ;
84681   int arg3 ;
84682
84683   arg1 = (std::vector< Dali::Actor > *)jarg1;
84684   arg2 = (int)jarg2;
84685   arg3 = (int)jarg3;
84686   {
84687     try {
84688       try {
84689         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
84690       }
84691       catch(std::out_of_range &_e) {
84692         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84693         return ;
84694       }
84695       catch(std::invalid_argument &_e) {
84696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
84697         return ;
84698       }
84699
84700     } catch (std::out_of_range& e) {
84701       {
84702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84703       };
84704     } catch (std::exception& e) {
84705       {
84706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84707       };
84708     } catch (...) {
84709       {
84710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84711       };
84712     }
84713   }
84714 }
84715
84716
84717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
84718   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84719   int arg2 ;
84720   std::vector< Dali::Actor > *arg3 = 0 ;
84721
84722   arg1 = (std::vector< Dali::Actor > *)jarg1;
84723   arg2 = (int)jarg2;
84724   arg3 = (std::vector< Dali::Actor > *)jarg3;
84725   if (!arg3) {
84726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
84727     return ;
84728   }
84729   {
84730     try {
84731       try {
84732         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
84733       }
84734       catch(std::out_of_range &_e) {
84735         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
84736         return ;
84737       }
84738
84739     } catch (std::out_of_range& e) {
84740       {
84741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84742       };
84743     } catch (std::exception& e) {
84744       {
84745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84746       };
84747     } catch (...) {
84748       {
84749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84750       };
84751     }
84752   }
84753 }
84754
84755
84756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
84757   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
84758
84759   arg1 = (std::vector< Dali::Actor > *)jarg1;
84760   {
84761     try {
84762       delete arg1;
84763     } catch (std::out_of_range& e) {
84764       {
84765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84766       };
84767     } catch (std::exception& e) {
84768       {
84769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84770       };
84771     } catch (...) {
84772       {
84773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84774       };
84775     }
84776   }
84777 }
84778
84779
84780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
84781   unsigned int jresult ;
84782   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84783   bool result;
84784
84785   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84786   {
84787     try {
84788       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84789     } catch (std::out_of_range& e) {
84790       {
84791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84792       };
84793     } catch (std::exception& e) {
84794       {
84795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84800       };
84801     }
84802   }
84803   jresult = result;
84804   return jresult;
84805 }
84806
84807
84808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
84809   unsigned long jresult ;
84810   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84811   std::size_t result;
84812
84813   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84814   {
84815     try {
84816       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
84817     } catch (std::out_of_range& e) {
84818       {
84819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (std::exception& e) {
84822       {
84823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84824       };
84825     } catch (...) {
84826       {
84827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84828       };
84829     }
84830   }
84831   jresult = (unsigned long)result;
84832   return jresult;
84833 }
84834
84835
84836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
84837   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84838   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84839
84840   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84841   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84842   {
84843     try {
84844       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
84845     } catch (std::out_of_range& e) {
84846       {
84847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84848       };
84849     } catch (std::exception& e) {
84850       {
84851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84852       };
84853     } catch (...) {
84854       {
84855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84856       };
84857     }
84858   }
84859 }
84860
84861
84862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
84863   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84864   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
84865
84866   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84867   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
84868   {
84869     try {
84870       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
84871     } catch (std::out_of_range& e) {
84872       {
84873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84874       };
84875     } catch (std::exception& e) {
84876       {
84877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84878       };
84879     } catch (...) {
84880       {
84881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84882       };
84883     }
84884   }
84885 }
84886
84887
84888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
84889   unsigned int jresult ;
84890   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84891   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
84892   bool result;
84893
84894   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84895   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
84896   if (!arg2) {
84897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
84898     return 0;
84899   }
84900   {
84901     try {
84902       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
84903     } catch (std::out_of_range& e) {
84904       {
84905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84906       };
84907     } catch (std::exception& e) {
84908       {
84909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (...) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84914       };
84915     }
84916   }
84917   jresult = result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
84923   void * jresult ;
84924   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
84925
84926   {
84927     try {
84928       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
84929     } catch (std::out_of_range& e) {
84930       {
84931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84932       };
84933     } catch (std::exception& e) {
84934       {
84935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84936       };
84937     } catch (...) {
84938       {
84939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84940       };
84941     }
84942   }
84943   jresult = (void *)result;
84944   return jresult;
84945 }
84946
84947
84948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
84949   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
84950
84951   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
84952   {
84953     try {
84954       delete arg1;
84955     } catch (std::out_of_range& e) {
84956       {
84957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84958       };
84959     } catch (std::exception& e) {
84960       {
84961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84962       };
84963     } catch (...) {
84964       {
84965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84966       };
84967     }
84968   }
84969 }
84970
84971
84972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
84973   unsigned int jresult ;
84974   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
84975   bool result;
84976
84977   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
84978   {
84979     try {
84980       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);
84981     } catch (std::out_of_range& e) {
84982       {
84983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84984       };
84985     } catch (std::exception& e) {
84986       {
84987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84988       };
84989     } catch (...) {
84990       {
84991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84992       };
84993     }
84994   }
84995   jresult = result;
84996   return jresult;
84997 }
84998
84999
85000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
85001   unsigned long jresult ;
85002   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85003   std::size_t result;
85004
85005   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85006   {
85007     try {
85008       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);
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85016       };
85017     } catch (...) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85020       };
85021     }
85022   }
85023   jresult = (unsigned long)result;
85024   return jresult;
85025 }
85026
85027
85028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
85029   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85030   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
85031
85032   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85033   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
85034   {
85035     try {
85036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
85037     } catch (std::out_of_range& e) {
85038       {
85039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85040       };
85041     } catch (std::exception& e) {
85042       {
85043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85044       };
85045     } catch (...) {
85046       {
85047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85048       };
85049     }
85050   }
85051 }
85052
85053
85054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
85055   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85056   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
85057
85058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85059   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
85060   {
85061     try {
85062       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
85063     } catch (std::out_of_range& e) {
85064       {
85065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85066       };
85067     } catch (std::exception& e) {
85068       {
85069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85070       };
85071     } catch (...) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85074       };
85075     }
85076   }
85077 }
85078
85079
85080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85081   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85082   Dali::Actor arg2 ;
85083   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
85084   Dali::Actor *argp2 ;
85085
85086   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85087   argp2 = (Dali::Actor *)jarg2;
85088   if (!argp2) {
85089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85090     return ;
85091   }
85092   arg2 = *argp2;
85093   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
85094   {
85095     try {
85096       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
85097     } catch (std::out_of_range& e) {
85098       {
85099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85100       };
85101     } catch (std::exception& e) {
85102       {
85103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85104       };
85105     } catch (...) {
85106       {
85107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85108       };
85109     }
85110   }
85111 }
85112
85113
85114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
85115   void * jresult ;
85116   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
85117
85118   {
85119     try {
85120       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
85121     } catch (std::out_of_range& e) {
85122       {
85123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85124       };
85125     } catch (std::exception& e) {
85126       {
85127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85128       };
85129     } catch (...) {
85130       {
85131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85132       };
85133     }
85134   }
85135   jresult = (void *)result;
85136   return jresult;
85137 }
85138
85139
85140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
85141   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
85142
85143   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
85144   {
85145     try {
85146       delete arg1;
85147     } catch (std::out_of_range& e) {
85148       {
85149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85150       };
85151     } catch (std::exception& e) {
85152       {
85153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85154       };
85155     } catch (...) {
85156       {
85157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85158       };
85159     }
85160   }
85161 }
85162
85163
85164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
85165   unsigned int jresult ;
85166   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85167   bool result;
85168
85169   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85170   {
85171     try {
85172       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85173     } catch (std::out_of_range& e) {
85174       {
85175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85176       };
85177     } catch (std::exception& e) {
85178       {
85179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85180       };
85181     } catch (...) {
85182       {
85183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85184       };
85185     }
85186   }
85187   jresult = result;
85188   return jresult;
85189 }
85190
85191
85192 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
85193   unsigned long jresult ;
85194   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85195   std::size_t result;
85196
85197   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85198   {
85199     try {
85200       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
85201     } catch (std::out_of_range& e) {
85202       {
85203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85204       };
85205     } catch (std::exception& e) {
85206       {
85207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85208       };
85209     } catch (...) {
85210       {
85211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85212       };
85213     }
85214   }
85215   jresult = (unsigned long)result;
85216   return jresult;
85217 }
85218
85219
85220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
85221   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85222   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85223
85224   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85225   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85226   {
85227     try {
85228       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
85229     } catch (std::out_of_range& e) {
85230       {
85231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85232       };
85233     } catch (std::exception& e) {
85234       {
85235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85236       };
85237     } catch (...) {
85238       {
85239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85240       };
85241     }
85242   }
85243 }
85244
85245
85246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85247   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85248   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
85249
85250   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85251   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
85252   {
85253     try {
85254       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
85255     } catch (std::out_of_range& e) {
85256       {
85257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85258       };
85259     } catch (std::exception& e) {
85260       {
85261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85262       };
85263     } catch (...) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85266       };
85267     }
85268   }
85269 }
85270
85271
85272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
85273   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85274   Dali::Actor arg2 ;
85275   Dali::Actor arg3 ;
85276   Dali::Actor *argp2 ;
85277   Dali::Actor *argp3 ;
85278
85279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85280   argp2 = (Dali::Actor *)jarg2;
85281   if (!argp2) {
85282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85283     return ;
85284   }
85285   arg2 = *argp2;
85286   argp3 = (Dali::Actor *)jarg3;
85287   if (!argp3) {
85288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85289     return ;
85290   }
85291   arg3 = *argp3;
85292   {
85293     try {
85294       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
85295     } catch (std::out_of_range& e) {
85296       {
85297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85298       };
85299     } catch (std::exception& e) {
85300       {
85301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85302       };
85303     } catch (...) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85306       };
85307     }
85308   }
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
85313   void * jresult ;
85314   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
85315
85316   {
85317     try {
85318       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
85319     } catch (std::out_of_range& e) {
85320       {
85321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85322       };
85323     } catch (std::exception& e) {
85324       {
85325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85326       };
85327     } catch (...) {
85328       {
85329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85330       };
85331     }
85332   }
85333   jresult = (void *)result;
85334   return jresult;
85335 }
85336
85337
85338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
85339   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
85340
85341   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
85342   {
85343     try {
85344       delete arg1;
85345     } catch (std::out_of_range& e) {
85346       {
85347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85348       };
85349     } catch (std::exception& e) {
85350       {
85351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85352       };
85353     } catch (...) {
85354       {
85355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85356       };
85357     }
85358   }
85359 }
85360
85361
85362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
85363   unsigned int jresult ;
85364   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85365   bool result;
85366
85367   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85368   {
85369     try {
85370       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85371     } catch (std::out_of_range& e) {
85372       {
85373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85374       };
85375     } catch (std::exception& e) {
85376       {
85377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85378       };
85379     } catch (...) {
85380       {
85381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85382       };
85383     }
85384   }
85385   jresult = result;
85386   return jresult;
85387 }
85388
85389
85390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
85391   unsigned long jresult ;
85392   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85393   std::size_t result;
85394
85395   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85396   {
85397     try {
85398       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
85399     } catch (std::out_of_range& e) {
85400       {
85401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (std::exception& e) {
85404       {
85405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85410       };
85411     }
85412   }
85413   jresult = (unsigned long)result;
85414   return jresult;
85415 }
85416
85417
85418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
85419   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85420   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85421
85422   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85423   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85424   {
85425     try {
85426       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
85427     } catch (std::out_of_range& e) {
85428       {
85429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85430       };
85431     } catch (std::exception& e) {
85432       {
85433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85434       };
85435     } catch (...) {
85436       {
85437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85438       };
85439     }
85440   }
85441 }
85442
85443
85444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85445   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85446   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
85447
85448   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85449   arg2 = (void (*)(Dali::Actor,bool))jarg2;
85450   {
85451     try {
85452       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
85453     } catch (std::out_of_range& e) {
85454       {
85455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85456       };
85457     } catch (std::exception& e) {
85458       {
85459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85460       };
85461     } catch (...) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85464       };
85465     }
85466   }
85467 }
85468
85469
85470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
85471   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85472   Dali::Actor arg2 ;
85473   bool arg3 ;
85474   Dali::Actor *argp2 ;
85475
85476   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85477   argp2 = (Dali::Actor *)jarg2;
85478   if (!argp2) {
85479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85480     return ;
85481   }
85482   arg2 = *argp2;
85483   arg3 = jarg3 ? true : false;
85484   {
85485     try {
85486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85494       };
85495     } catch (...) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85498       };
85499     }
85500   }
85501 }
85502
85503
85504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
85505   void * jresult ;
85506   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
85507
85508   {
85509     try {
85510       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
85511     } catch (std::out_of_range& e) {
85512       {
85513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85514       };
85515     } catch (std::exception& e) {
85516       {
85517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85518       };
85519     } catch (...) {
85520       {
85521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85522       };
85523     }
85524   }
85525   jresult = (void *)result;
85526   return jresult;
85527 }
85528
85529
85530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
85531   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
85532
85533   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
85534   {
85535     try {
85536       delete arg1;
85537     } catch (std::out_of_range& e) {
85538       {
85539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85540       };
85541     } catch (std::exception& e) {
85542       {
85543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85544       };
85545     } catch (...) {
85546       {
85547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85548       };
85549     }
85550   }
85551 }
85552
85553
85554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
85555   unsigned int jresult ;
85556   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85557   bool result;
85558
85559   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85560   {
85561     try {
85562       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);
85563     } catch (std::out_of_range& e) {
85564       {
85565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85566       };
85567     } catch (std::exception& e) {
85568       {
85569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85570       };
85571     } catch (...) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85574       };
85575     }
85576   }
85577   jresult = result;
85578   return jresult;
85579 }
85580
85581
85582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
85583   unsigned long jresult ;
85584   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85585   std::size_t result;
85586
85587   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85588   {
85589     try {
85590       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);
85591     } catch (std::out_of_range& e) {
85592       {
85593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85594       };
85595     } catch (std::exception& e) {
85596       {
85597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85598       };
85599     } catch (...) {
85600       {
85601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85602       };
85603     }
85604   }
85605   jresult = (unsigned long)result;
85606   return jresult;
85607 }
85608
85609
85610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
85611   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85612   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85613
85614   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85615   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85616   {
85617     try {
85618       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85626       };
85627     } catch (...) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85630       };
85631     }
85632   }
85633 }
85634
85635
85636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
85637   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85638   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
85639
85640   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85641   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
85642   {
85643     try {
85644       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
85645     } catch (std::out_of_range& e) {
85646       {
85647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85648       };
85649     } catch (std::exception& e) {
85650       {
85651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85652       };
85653     } catch (...) {
85654       {
85655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85656       };
85657     }
85658   }
85659 }
85660
85661
85662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
85663   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85664   Dali::Toolkit::StyleManager arg2 ;
85665   Dali::StyleChange::Type arg3 ;
85666   Dali::Toolkit::StyleManager *argp2 ;
85667
85668   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85669   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
85670   if (!argp2) {
85671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
85672     return ;
85673   }
85674   arg2 = *argp2;
85675   arg3 = (Dali::StyleChange::Type)jarg3;
85676   {
85677     try {
85678       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85686       };
85687     } catch (...) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85690       };
85691     }
85692   }
85693 }
85694
85695
85696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
85697   void * jresult ;
85698   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
85699
85700   {
85701     try {
85702       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
85703     } catch (std::out_of_range& e) {
85704       {
85705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85706       };
85707     } catch (std::exception& e) {
85708       {
85709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85710       };
85711     } catch (...) {
85712       {
85713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85714       };
85715     }
85716   }
85717   jresult = (void *)result;
85718   return jresult;
85719 }
85720
85721
85722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
85723   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
85724
85725   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
85726   {
85727     try {
85728       delete arg1;
85729     } catch (std::out_of_range& e) {
85730       {
85731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85732       };
85733     } catch (std::exception& e) {
85734       {
85735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85736       };
85737     } catch (...) {
85738       {
85739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85740       };
85741     }
85742   }
85743 }
85744
85745
85746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
85747   unsigned int jresult ;
85748   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85749   bool result;
85750
85751   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85752   {
85753     try {
85754       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85762       };
85763     } catch (...) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85766       };
85767     }
85768   }
85769   jresult = result;
85770   return jresult;
85771 }
85772
85773
85774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
85775   unsigned long jresult ;
85776   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85777   std::size_t result;
85778
85779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85780   {
85781     try {
85782       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85790       };
85791     } catch (...) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85794       };
85795     }
85796   }
85797   jresult = (unsigned long)result;
85798   return jresult;
85799 }
85800
85801
85802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
85803   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85804   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85805
85806   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85807   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85808   {
85809     try {
85810       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
85811     } catch (std::out_of_range& e) {
85812       {
85813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85814       };
85815     } catch (std::exception& e) {
85816       {
85817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85818       };
85819     } catch (...) {
85820       {
85821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85822       };
85823     }
85824   }
85825 }
85826
85827
85828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
85829   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85830   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
85831
85832   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85833   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
85834   {
85835     try {
85836       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
85837     } catch (std::out_of_range& e) {
85838       {
85839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85840       };
85841     } catch (std::exception& e) {
85842       {
85843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85844       };
85845     } catch (...) {
85846       {
85847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85848       };
85849     }
85850   }
85851 }
85852
85853
85854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
85855   unsigned int jresult ;
85856   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85857   Dali::Toolkit::Button arg2 ;
85858   Dali::Toolkit::Button *argp2 ;
85859   bool result;
85860
85861   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85862   argp2 = (Dali::Toolkit::Button *)jarg2;
85863   if (!argp2) {
85864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
85865     return 0;
85866   }
85867   arg2 = *argp2;
85868   {
85869     try {
85870       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
85871     } catch (std::out_of_range& e) {
85872       {
85873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85874       };
85875     } catch (std::exception& e) {
85876       {
85877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85878       };
85879     } catch (...) {
85880       {
85881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85882       };
85883     }
85884   }
85885   jresult = result;
85886   return jresult;
85887 }
85888
85889
85890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
85891   void * jresult ;
85892   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
85893
85894   {
85895     try {
85896       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
85897     } catch (std::out_of_range& e) {
85898       {
85899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85900       };
85901     } catch (std::exception& e) {
85902       {
85903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (...) {
85906       {
85907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85908       };
85909     }
85910   }
85911   jresult = (void *)result;
85912   return jresult;
85913 }
85914
85915
85916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
85917   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
85918
85919   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
85920   {
85921     try {
85922       delete arg1;
85923     } catch (std::out_of_range& e) {
85924       {
85925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85926       };
85927     } catch (std::exception& e) {
85928       {
85929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85930       };
85931     } catch (...) {
85932       {
85933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85934       };
85935     }
85936   }
85937 }
85938
85939
85940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
85941   unsigned int jresult ;
85942   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85943   bool result;
85944
85945   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85946   {
85947     try {
85948       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85949     } catch (std::out_of_range& e) {
85950       {
85951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (std::exception& e) {
85954       {
85955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (...) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85960       };
85961     }
85962   }
85963   jresult = result;
85964   return jresult;
85965 }
85966
85967
85968 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
85969   unsigned long jresult ;
85970   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85971   std::size_t result;
85972
85973   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
85974   {
85975     try {
85976       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
85977     } catch (std::out_of_range& e) {
85978       {
85979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85980       };
85981     } catch (std::exception& e) {
85982       {
85983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85984       };
85985     } catch (...) {
85986       {
85987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85988       };
85989     }
85990   }
85991   jresult = (unsigned long)result;
85992   return jresult;
85993 }
85994
85995
85996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
85997   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
85998   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
85999
86000   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86001   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
86002   {
86003     try {
86004       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
86005     } catch (std::out_of_range& e) {
86006       {
86007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86008       };
86009     } catch (std::exception& e) {
86010       {
86011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86016       };
86017     }
86018   }
86019 }
86020
86021
86022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
86023   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86024   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
86025
86026   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86027   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
86028   {
86029     try {
86030       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
86031     } catch (std::out_of_range& e) {
86032       {
86033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86034       };
86035     } catch (std::exception& e) {
86036       {
86037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86038       };
86039     } catch (...) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86042       };
86043     }
86044   }
86045 }
86046
86047
86048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
86049   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86050   Dali::Toolkit::GaussianBlurView arg2 ;
86051   Dali::Toolkit::GaussianBlurView *argp2 ;
86052
86053   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86054   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
86055   if (!argp2) {
86056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
86057     return ;
86058   }
86059   arg2 = *argp2;
86060   {
86061     try {
86062       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
86063     } catch (std::out_of_range& e) {
86064       {
86065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86066       };
86067     } catch (std::exception& e) {
86068       {
86069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86070       };
86071     } catch (...) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86074       };
86075     }
86076   }
86077 }
86078
86079
86080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
86081   void * jresult ;
86082   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
86083
86084   {
86085     try {
86086       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
86087     } catch (std::out_of_range& e) {
86088       {
86089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86090       };
86091     } catch (std::exception& e) {
86092       {
86093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (...) {
86096       {
86097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86098       };
86099     }
86100   }
86101   jresult = (void *)result;
86102   return jresult;
86103 }
86104
86105
86106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
86107   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
86108
86109   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
86110   {
86111     try {
86112       delete arg1;
86113     } catch (std::out_of_range& e) {
86114       {
86115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86116       };
86117     } catch (std::exception& e) {
86118       {
86119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86120       };
86121     } catch (...) {
86122       {
86123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86124       };
86125     }
86126   }
86127 }
86128
86129
86130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
86131   unsigned int jresult ;
86132   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86133   bool result;
86134
86135   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86136   {
86137     try {
86138       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);
86139     } catch (std::out_of_range& e) {
86140       {
86141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86142       };
86143     } catch (std::exception& e) {
86144       {
86145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86146       };
86147     } catch (...) {
86148       {
86149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86150       };
86151     }
86152   }
86153   jresult = result;
86154   return jresult;
86155 }
86156
86157
86158 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
86159   unsigned long jresult ;
86160   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86161   std::size_t result;
86162
86163   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86164   {
86165     try {
86166       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);
86167     } catch (std::out_of_range& e) {
86168       {
86169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86170       };
86171     } catch (std::exception& e) {
86172       {
86173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86174       };
86175     } catch (...) {
86176       {
86177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86178       };
86179     }
86180   }
86181   jresult = (unsigned long)result;
86182   return jresult;
86183 }
86184
86185
86186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
86187   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86188   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86189
86190   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86191   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86192   {
86193     try {
86194       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
86195     } catch (std::out_of_range& e) {
86196       {
86197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86198       };
86199     } catch (std::exception& e) {
86200       {
86201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86202       };
86203     } catch (...) {
86204       {
86205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86206       };
86207     }
86208   }
86209 }
86210
86211
86212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
86213   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86214   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
86215
86216   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86217   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
86218   {
86219     try {
86220       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
86221     } catch (std::out_of_range& e) {
86222       {
86223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86224       };
86225     } catch (std::exception& e) {
86226       {
86227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86228       };
86229     } catch (...) {
86230       {
86231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86232       };
86233     }
86234   }
86235 }
86236
86237
86238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
86239   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86240   Dali::Toolkit::PageTurnView arg2 ;
86241   unsigned int arg3 ;
86242   bool arg4 ;
86243   Dali::Toolkit::PageTurnView *argp2 ;
86244
86245   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86246   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86247   if (!argp2) {
86248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86249     return ;
86250   }
86251   arg2 = *argp2;
86252   arg3 = (unsigned int)jarg3;
86253   arg4 = jarg4 ? true : false;
86254   {
86255     try {
86256       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86257     } catch (std::out_of_range& e) {
86258       {
86259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86260       };
86261     } catch (std::exception& e) {
86262       {
86263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86264       };
86265     } catch (...) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86268       };
86269     }
86270   }
86271 }
86272
86273
86274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
86275   void * jresult ;
86276   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
86277
86278   {
86279     try {
86280       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
86281     } catch (std::out_of_range& e) {
86282       {
86283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (std::exception& e) {
86286       {
86287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86288       };
86289     } catch (...) {
86290       {
86291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86292       };
86293     }
86294   }
86295   jresult = (void *)result;
86296   return jresult;
86297 }
86298
86299
86300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
86301   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
86302
86303   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
86304   {
86305     try {
86306       delete arg1;
86307     } catch (std::out_of_range& e) {
86308       {
86309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86310       };
86311     } catch (std::exception& e) {
86312       {
86313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86314       };
86315     } catch (...) {
86316       {
86317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86318       };
86319     }
86320   }
86321 }
86322
86323
86324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
86325   unsigned int jresult ;
86326   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86327   bool result;
86328
86329   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86330   {
86331     try {
86332       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86333     } catch (std::out_of_range& e) {
86334       {
86335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86336       };
86337     } catch (std::exception& e) {
86338       {
86339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86340       };
86341     } catch (...) {
86342       {
86343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86344       };
86345     }
86346   }
86347   jresult = result;
86348   return jresult;
86349 }
86350
86351
86352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
86353   unsigned long jresult ;
86354   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86355   std::size_t result;
86356
86357   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86358   {
86359     try {
86360       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
86361     } catch (std::out_of_range& e) {
86362       {
86363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86364       };
86365     } catch (std::exception& e) {
86366       {
86367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86368       };
86369     } catch (...) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86372       };
86373     }
86374   }
86375   jresult = (unsigned long)result;
86376   return jresult;
86377 }
86378
86379
86380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
86381   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86382   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86383
86384   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86385   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86386   {
86387     try {
86388       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
86389     } catch (std::out_of_range& e) {
86390       {
86391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86392       };
86393     } catch (std::exception& e) {
86394       {
86395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86400       };
86401     }
86402   }
86403 }
86404
86405
86406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
86407   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86408   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
86409
86410   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86411   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
86412   {
86413     try {
86414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
86415     } catch (std::out_of_range& e) {
86416       {
86417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86418       };
86419     } catch (std::exception& e) {
86420       {
86421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86422       };
86423     } catch (...) {
86424       {
86425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86426       };
86427     }
86428   }
86429 }
86430
86431
86432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
86433   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86434   Dali::Toolkit::PageTurnView arg2 ;
86435   Dali::Toolkit::PageTurnView *argp2 ;
86436
86437   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86438   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
86439   if (!argp2) {
86440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
86441     return ;
86442   }
86443   arg2 = *argp2;
86444   {
86445     try {
86446       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
86447     } catch (std::out_of_range& e) {
86448       {
86449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86450       };
86451     } catch (std::exception& e) {
86452       {
86453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86454       };
86455     } catch (...) {
86456       {
86457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86458       };
86459     }
86460   }
86461 }
86462
86463
86464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
86465   void * jresult ;
86466   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
86467
86468   {
86469     try {
86470       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
86471     } catch (std::out_of_range& e) {
86472       {
86473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86474       };
86475     } catch (std::exception& e) {
86476       {
86477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86478       };
86479     } catch (...) {
86480       {
86481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86482       };
86483     }
86484   }
86485   jresult = (void *)result;
86486   return jresult;
86487 }
86488
86489
86490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
86491   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
86492
86493   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
86494   {
86495     try {
86496       delete arg1;
86497     } catch (std::out_of_range& e) {
86498       {
86499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86500       };
86501     } catch (std::exception& e) {
86502       {
86503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86504       };
86505     } catch (...) {
86506       {
86507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86508       };
86509     }
86510   }
86511 }
86512
86513
86514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
86515   unsigned int jresult ;
86516   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86517   bool result;
86518
86519   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86520   {
86521     try {
86522       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);
86523     } catch (std::out_of_range& e) {
86524       {
86525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86526       };
86527     } catch (std::exception& e) {
86528       {
86529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86530       };
86531     } catch (...) {
86532       {
86533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86534       };
86535     }
86536   }
86537   jresult = result;
86538   return jresult;
86539 }
86540
86541
86542 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
86543   unsigned long jresult ;
86544   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86545   std::size_t result;
86546
86547   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86548   {
86549     try {
86550       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);
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (...) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86562       };
86563     }
86564   }
86565   jresult = (unsigned long)result;
86566   return jresult;
86567 }
86568
86569
86570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
86571   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86572   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86573
86574   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86575   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86576   {
86577     try {
86578       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
86579     } catch (std::out_of_range& e) {
86580       {
86581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86582       };
86583     } catch (std::exception& e) {
86584       {
86585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86586       };
86587     } catch (...) {
86588       {
86589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86590       };
86591     }
86592   }
86593 }
86594
86595
86596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
86597   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86598   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
86599
86600   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86601   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
86602   {
86603     try {
86604       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
86605     } catch (std::out_of_range& e) {
86606       {
86607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86608       };
86609     } catch (std::exception& e) {
86610       {
86611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86612       };
86613     } catch (...) {
86614       {
86615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86616       };
86617     }
86618   }
86619 }
86620
86621
86622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
86623   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86624   Dali::Toolkit::ProgressBar arg2 ;
86625   float arg3 ;
86626   float arg4 ;
86627   Dali::Toolkit::ProgressBar *argp2 ;
86628
86629   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86630   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
86631   if (!argp2) {
86632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
86633     return ;
86634   }
86635   arg2 = *argp2;
86636   arg3 = (float)jarg3;
86637   arg4 = (float)jarg4;
86638   {
86639     try {
86640       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
86641     } catch (std::out_of_range& e) {
86642       {
86643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86644       };
86645     } catch (std::exception& e) {
86646       {
86647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86648       };
86649     } catch (...) {
86650       {
86651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86652       };
86653     }
86654   }
86655 }
86656
86657
86658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
86659   void * jresult ;
86660   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
86661
86662   {
86663     try {
86664       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
86665     } catch (std::out_of_range& e) {
86666       {
86667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86668       };
86669     } catch (std::exception& e) {
86670       {
86671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86672       };
86673     } catch (...) {
86674       {
86675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86676       };
86677     }
86678   }
86679   jresult = (void *)result;
86680   return jresult;
86681 }
86682
86683
86684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
86685   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
86686
86687   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
86688   {
86689     try {
86690       delete arg1;
86691     } catch (std::out_of_range& e) {
86692       {
86693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86694       };
86695     } catch (std::exception& e) {
86696       {
86697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86698       };
86699     } catch (...) {
86700       {
86701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86702       };
86703     }
86704   }
86705 }
86706
86707
86708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
86709   unsigned int jresult ;
86710   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86711   bool result;
86712
86713   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86714   {
86715     try {
86716       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);
86717     } catch (std::out_of_range& e) {
86718       {
86719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86720       };
86721     } catch (std::exception& e) {
86722       {
86723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86724       };
86725     } catch (...) {
86726       {
86727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86728       };
86729     }
86730   }
86731   jresult = result;
86732   return jresult;
86733 }
86734
86735
86736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
86737   unsigned long jresult ;
86738   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86739   std::size_t result;
86740
86741   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86742   {
86743     try {
86744       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);
86745     } catch (std::out_of_range& e) {
86746       {
86747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86748       };
86749     } catch (std::exception& e) {
86750       {
86751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86752       };
86753     } catch (...) {
86754       {
86755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86756       };
86757     }
86758   }
86759   jresult = (unsigned long)result;
86760   return jresult;
86761 }
86762
86763
86764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
86765   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86766   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86767
86768   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86769   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86770   {
86771     try {
86772       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86773     } catch (std::out_of_range& e) {
86774       {
86775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86776       };
86777     } catch (std::exception& e) {
86778       {
86779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86780       };
86781     } catch (...) {
86782       {
86783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86784       };
86785     }
86786   }
86787 }
86788
86789
86790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
86791   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86792   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
86793
86794   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86795   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
86796   {
86797     try {
86798       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86799     } catch (std::out_of_range& e) {
86800       {
86801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86802       };
86803     } catch (std::exception& e) {
86804       {
86805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86806       };
86807     } catch (...) {
86808       {
86809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86810       };
86811     }
86812   }
86813 }
86814
86815
86816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
86817   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86818   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
86819
86820   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86821   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
86822   if (!arg2) {
86823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
86824     return ;
86825   }
86826   {
86827     try {
86828       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
86829     } catch (std::out_of_range& e) {
86830       {
86831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86832       };
86833     } catch (std::exception& e) {
86834       {
86835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86836       };
86837     } catch (...) {
86838       {
86839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86840       };
86841     }
86842   }
86843 }
86844
86845
86846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
86847   void * jresult ;
86848   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
86849
86850   {
86851     try {
86852       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
86853     } catch (std::out_of_range& e) {
86854       {
86855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86856       };
86857     } catch (std::exception& e) {
86858       {
86859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86860       };
86861     } catch (...) {
86862       {
86863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86864       };
86865     }
86866   }
86867   jresult = (void *)result;
86868   return jresult;
86869 }
86870
86871
86872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
86873   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
86874
86875   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
86876   {
86877     try {
86878       delete arg1;
86879     } catch (std::out_of_range& e) {
86880       {
86881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86882       };
86883     } catch (std::exception& e) {
86884       {
86885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86886       };
86887     } catch (...) {
86888       {
86889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86890       };
86891     }
86892   }
86893 }
86894
86895
86896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
86897   unsigned int jresult ;
86898   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86899   bool result;
86900
86901   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86902   {
86903     try {
86904       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86905     } catch (std::out_of_range& e) {
86906       {
86907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86908       };
86909     } catch (std::exception& e) {
86910       {
86911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86912       };
86913     } catch (...) {
86914       {
86915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86916       };
86917     }
86918   }
86919   jresult = result;
86920   return jresult;
86921 }
86922
86923
86924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
86925   unsigned long jresult ;
86926   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86927   std::size_t result;
86928
86929   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86930   {
86931     try {
86932       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
86933     } catch (std::out_of_range& e) {
86934       {
86935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86936       };
86937     } catch (std::exception& e) {
86938       {
86939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86940       };
86941     } catch (...) {
86942       {
86943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86944       };
86945     }
86946   }
86947   jresult = (unsigned long)result;
86948   return jresult;
86949 }
86950
86951
86952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
86953   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86954   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86955
86956   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86957   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86958   {
86959     try {
86960       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
86961     } catch (std::out_of_range& e) {
86962       {
86963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86964       };
86965     } catch (std::exception& e) {
86966       {
86967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86968       };
86969     } catch (...) {
86970       {
86971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86972       };
86973     }
86974   }
86975 }
86976
86977
86978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
86979   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
86980   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
86981
86982   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
86983   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
86984   {
86985     try {
86986       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
86987     } catch (std::out_of_range& e) {
86988       {
86989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86990       };
86991     } catch (std::exception& e) {
86992       {
86993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86994       };
86995     } catch (...) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86998       };
86999     }
87000   }
87001 }
87002
87003
87004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
87005   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
87006   Dali::Vector2 *arg2 = 0 ;
87007
87008   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
87009   arg2 = (Dali::Vector2 *)jarg2;
87010   if (!arg2) {
87011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
87012     return ;
87013   }
87014   {
87015     try {
87016       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
87017     } catch (std::out_of_range& e) {
87018       {
87019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87020       };
87021     } catch (std::exception& e) {
87022       {
87023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87024       };
87025     } catch (...) {
87026       {
87027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87028       };
87029     }
87030   }
87031 }
87032
87033
87034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
87035   void * jresult ;
87036   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
87037
87038   {
87039     try {
87040       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
87041     } catch (std::out_of_range& e) {
87042       {
87043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87044       };
87045     } catch (std::exception& e) {
87046       {
87047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87048       };
87049     } catch (...) {
87050       {
87051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87052       };
87053     }
87054   }
87055   jresult = (void *)result;
87056   return jresult;
87057 }
87058
87059
87060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
87061   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
87062
87063   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
87064   {
87065     try {
87066       delete arg1;
87067     } catch (std::out_of_range& e) {
87068       {
87069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87070       };
87071     } catch (std::exception& e) {
87072       {
87073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87074       };
87075     } catch (...) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87078       };
87079     }
87080   }
87081 }
87082
87083
87084
87085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
87086   unsigned int jresult ;
87087   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87088   bool result;
87089
87090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87091   {
87092     try {
87093       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);
87094     } catch (std::out_of_range& e) {
87095       {
87096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87097       };
87098     } catch (std::exception& e) {
87099       {
87100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87101       };
87102     } catch (...) {
87103       {
87104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87105       };
87106     }
87107   }
87108   jresult = result;
87109   return jresult;
87110 }
87111
87112
87113 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
87114   unsigned long jresult ;
87115   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87116   std::size_t result;
87117
87118   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87119   {
87120     try {
87121       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);
87122     } catch (std::out_of_range& e) {
87123       {
87124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87125       };
87126     } catch (std::exception& e) {
87127       {
87128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87129       };
87130     } catch (...) {
87131       {
87132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87133       };
87134     }
87135   }
87136   jresult = (unsigned long)result;
87137   return jresult;
87138 }
87139
87140
87141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
87142   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87143   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87144
87145   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87146   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87147   {
87148     try {
87149       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
87150     } catch (std::out_of_range& e) {
87151       {
87152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87153       };
87154     } catch (std::exception& e) {
87155       {
87156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87157       };
87158     } catch (...) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87161       };
87162     }
87163   }
87164 }
87165
87166
87167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
87168   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87169   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
87170
87171   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87172   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
87173   {
87174     try {
87175       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
87176     } catch (std::out_of_range& e) {
87177       {
87178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87179       };
87180     } catch (std::exception& e) {
87181       {
87182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87183       };
87184     } catch (...) {
87185       {
87186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87187       };
87188     }
87189   }
87190 }
87191
87192
87193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
87194   unsigned int jresult ;
87195   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87196   Dali::Toolkit::Control arg2 ;
87197   Dali::KeyEvent *arg3 = 0 ;
87198   Dali::Toolkit::Control *argp2 ;
87199   bool result;
87200
87201   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87202   argp2 = (Dali::Toolkit::Control *)jarg2;
87203   if (!argp2) {
87204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87205     return 0;
87206   }
87207   arg2 = *argp2;
87208   arg3 = (Dali::KeyEvent *)jarg3;
87209   if (!arg3) {
87210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
87211     return 0;
87212   }
87213   {
87214     try {
87215       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);
87216     } catch (std::out_of_range& e) {
87217       {
87218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87219       };
87220     } catch (std::exception& e) {
87221       {
87222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87223       };
87224     } catch (...) {
87225       {
87226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87227       };
87228     }
87229   }
87230   jresult = result;
87231   return jresult;
87232 }
87233
87234
87235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
87236   void * jresult ;
87237   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
87238
87239   {
87240     try {
87241       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
87242     } catch (std::out_of_range& e) {
87243       {
87244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87245       };
87246     } catch (std::exception& e) {
87247       {
87248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87249       };
87250     } catch (...) {
87251       {
87252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87253       };
87254     }
87255   }
87256   jresult = (void *)result;
87257   return jresult;
87258 }
87259
87260
87261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
87262   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
87263
87264   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
87265   {
87266     try {
87267       delete arg1;
87268     } catch (std::out_of_range& e) {
87269       {
87270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87271       };
87272     } catch (std::exception& e) {
87273       {
87274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87275       };
87276     } catch (...) {
87277       {
87278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87279       };
87280     }
87281   }
87282 }
87283
87284
87285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
87286   unsigned int jresult ;
87287   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87288   bool result;
87289
87290   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87291   {
87292     try {
87293       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87294     } catch (std::out_of_range& e) {
87295       {
87296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87297       };
87298     } catch (std::exception& e) {
87299       {
87300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87301       };
87302     } catch (...) {
87303       {
87304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87305       };
87306     }
87307   }
87308   jresult = result;
87309   return jresult;
87310 }
87311
87312
87313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
87314   unsigned long jresult ;
87315   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87316   std::size_t result;
87317
87318   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87319   {
87320     try {
87321       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
87322     } catch (std::out_of_range& e) {
87323       {
87324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87325       };
87326     } catch (std::exception& e) {
87327       {
87328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87329       };
87330     } catch (...) {
87331       {
87332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87333       };
87334     }
87335   }
87336   jresult = (unsigned long)result;
87337   return jresult;
87338 }
87339
87340
87341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
87342   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87343   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87344
87345   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87346   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87347   {
87348     try {
87349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
87350     } catch (std::out_of_range& e) {
87351       {
87352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87353       };
87354     } catch (std::exception& e) {
87355       {
87356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87357       };
87358     } catch (...) {
87359       {
87360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87361       };
87362     }
87363   }
87364 }
87365
87366
87367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
87368   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87369   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
87370
87371   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87372   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
87373   {
87374     try {
87375       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
87376     } catch (std::out_of_range& e) {
87377       {
87378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87379       };
87380     } catch (std::exception& e) {
87381       {
87382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87383       };
87384     } catch (...) {
87385       {
87386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87387       };
87388     }
87389   }
87390 }
87391
87392
87393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
87394   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87395   Dali::Toolkit::Control arg2 ;
87396   Dali::Toolkit::Control *argp2 ;
87397
87398   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87399   argp2 = (Dali::Toolkit::Control *)jarg2;
87400   if (!argp2) {
87401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87402     return ;
87403   }
87404   arg2 = *argp2;
87405   {
87406     try {
87407       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
87408     } catch (std::out_of_range& e) {
87409       {
87410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87411       };
87412     } catch (std::exception& e) {
87413       {
87414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87415       };
87416     } catch (...) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87419       };
87420     }
87421   }
87422 }
87423
87424
87425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
87426   void * jresult ;
87427   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
87428
87429   {
87430     try {
87431       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
87432     } catch (std::out_of_range& e) {
87433       {
87434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87435       };
87436     } catch (std::exception& e) {
87437       {
87438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87439       };
87440     } catch (...) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87443       };
87444     }
87445   }
87446   jresult = (void *)result;
87447   return jresult;
87448 }
87449
87450
87451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
87452   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
87453
87454   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
87455   {
87456     try {
87457       delete arg1;
87458     } catch (std::out_of_range& e) {
87459       {
87460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87461       };
87462     } catch (std::exception& e) {
87463       {
87464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87465       };
87466     } catch (...) {
87467       {
87468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87469       };
87470     }
87471   }
87472 }
87473
87474
87475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
87476   unsigned int jresult ;
87477   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87478   bool result;
87479
87480   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87481   {
87482     try {
87483       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87484     } catch (std::out_of_range& e) {
87485       {
87486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87487       };
87488     } catch (std::exception& e) {
87489       {
87490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87491       };
87492     } catch (...) {
87493       {
87494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87495       };
87496     }
87497   }
87498   jresult = result;
87499   return jresult;
87500 }
87501
87502
87503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
87504   unsigned long jresult ;
87505   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87506   std::size_t result;
87507
87508   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87509   {
87510     try {
87511       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87519       };
87520     } catch (...) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87523       };
87524     }
87525   }
87526   jresult = (unsigned long)result;
87527   return jresult;
87528 }
87529
87530
87531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
87532   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87533   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87534
87535   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87536   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87537   {
87538     try {
87539       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
87540     } catch (std::out_of_range& e) {
87541       {
87542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87543       };
87544     } catch (std::exception& e) {
87545       {
87546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87547       };
87548     } catch (...) {
87549       {
87550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87551       };
87552     }
87553   }
87554 }
87555
87556
87557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
87558   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87559   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
87560
87561   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87562   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
87563   {
87564     try {
87565       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87577       };
87578     }
87579   }
87580 }
87581
87582
87583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
87584   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87585   Dali::Toolkit::VideoView *arg2 = 0 ;
87586
87587   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87588   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87589   if (!arg2) {
87590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
87591     return ;
87592   }
87593   {
87594     try {
87595       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
87596     } catch (std::out_of_range& e) {
87597       {
87598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87599       };
87600     } catch (std::exception& e) {
87601       {
87602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87603       };
87604     } catch (...) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87607       };
87608     }
87609   }
87610 }
87611
87612
87613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
87614   void * jresult ;
87615   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
87616
87617   {
87618     try {
87619       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
87620     } catch (std::out_of_range& e) {
87621       {
87622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87623       };
87624     } catch (std::exception& e) {
87625       {
87626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87627       };
87628     } catch (...) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87631       };
87632     }
87633   }
87634   jresult = (void *)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
87640   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
87641
87642   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
87643   {
87644     try {
87645       delete arg1;
87646     } catch (std::out_of_range& e) {
87647       {
87648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87649       };
87650     } catch (std::exception& e) {
87651       {
87652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87653       };
87654     } catch (...) {
87655       {
87656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87657       };
87658     }
87659   }
87660 }
87661
87662
87663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
87664   unsigned int jresult ;
87665   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87666   bool result;
87667
87668   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87669   {
87670     try {
87671       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87672     } catch (std::out_of_range& e) {
87673       {
87674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87675       };
87676     } catch (std::exception& e) {
87677       {
87678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87679       };
87680     } catch (...) {
87681       {
87682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87683       };
87684     }
87685   }
87686   jresult = result;
87687   return jresult;
87688 }
87689
87690
87691 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
87692   unsigned long jresult ;
87693   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87694   std::size_t result;
87695
87696   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87697   {
87698     try {
87699       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
87700     } catch (std::out_of_range& e) {
87701       {
87702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87703       };
87704     } catch (std::exception& e) {
87705       {
87706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87707       };
87708     } catch (...) {
87709       {
87710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87711       };
87712     }
87713   }
87714   jresult = (unsigned long)result;
87715   return jresult;
87716 }
87717
87718
87719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
87720   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87721   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87722
87723   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87724   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87725   {
87726     try {
87727       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
87728     } catch (std::out_of_range& e) {
87729       {
87730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87731       };
87732     } catch (std::exception& e) {
87733       {
87734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87739       };
87740     }
87741   }
87742 }
87743
87744
87745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
87746   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87747   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
87748
87749   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87750   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
87751   {
87752     try {
87753       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (...) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87765       };
87766     }
87767   }
87768 }
87769
87770
87771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
87772   unsigned int jresult ;
87773   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87774   Dali::Toolkit::Slider arg2 ;
87775   float arg3 ;
87776   Dali::Toolkit::Slider *argp2 ;
87777   bool result;
87778
87779   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87780   argp2 = (Dali::Toolkit::Slider *)jarg2;
87781   if (!argp2) {
87782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87783     return 0;
87784   }
87785   arg2 = *argp2;
87786   arg3 = (float)jarg3;
87787   {
87788     try {
87789       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
87790     } catch (std::out_of_range& e) {
87791       {
87792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87793       };
87794     } catch (std::exception& e) {
87795       {
87796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87797       };
87798     } catch (...) {
87799       {
87800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87801       };
87802     }
87803   }
87804   jresult = result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
87810   void * jresult ;
87811   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
87812
87813   {
87814     try {
87815       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
87816     } catch (std::out_of_range& e) {
87817       {
87818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (std::exception& e) {
87821       {
87822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87823       };
87824     } catch (...) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87827       };
87828     }
87829   }
87830   jresult = (void *)result;
87831   return jresult;
87832 }
87833
87834
87835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
87836   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
87837
87838   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
87839   {
87840     try {
87841       delete arg1;
87842     } catch (std::out_of_range& e) {
87843       {
87844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87845       };
87846     } catch (std::exception& e) {
87847       {
87848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87849       };
87850     } catch (...) {
87851       {
87852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87853       };
87854     }
87855   }
87856 }
87857
87858
87859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
87860   unsigned int jresult ;
87861   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87862   bool result;
87863
87864   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87865   {
87866     try {
87867       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87868     } catch (std::out_of_range& e) {
87869       {
87870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87871       };
87872     } catch (std::exception& e) {
87873       {
87874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87875       };
87876     } catch (...) {
87877       {
87878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87879       };
87880     }
87881   }
87882   jresult = result;
87883   return jresult;
87884 }
87885
87886
87887 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
87888   unsigned long jresult ;
87889   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87890   std::size_t result;
87891
87892   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87893   {
87894     try {
87895       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
87896     } catch (std::out_of_range& e) {
87897       {
87898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87899       };
87900     } catch (std::exception& e) {
87901       {
87902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87903       };
87904     } catch (...) {
87905       {
87906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87907       };
87908     }
87909   }
87910   jresult = (unsigned long)result;
87911   return jresult;
87912 }
87913
87914
87915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
87916   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87917   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87918
87919   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87920   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87921   {
87922     try {
87923       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
87924     } catch (std::out_of_range& e) {
87925       {
87926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87927       };
87928     } catch (std::exception& e) {
87929       {
87930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87931       };
87932     } catch (...) {
87933       {
87934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87935       };
87936     }
87937   }
87938 }
87939
87940
87941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
87942   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87943   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
87944
87945   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87946   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
87947   {
87948     try {
87949       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
87950     } catch (std::out_of_range& e) {
87951       {
87952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87953       };
87954     } catch (std::exception& e) {
87955       {
87956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87957       };
87958     } catch (...) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87961       };
87962     }
87963   }
87964 }
87965
87966
87967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
87968   unsigned int jresult ;
87969   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
87970   Dali::Toolkit::Slider arg2 ;
87971   int arg3 ;
87972   Dali::Toolkit::Slider *argp2 ;
87973   bool result;
87974
87975   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
87976   argp2 = (Dali::Toolkit::Slider *)jarg2;
87977   if (!argp2) {
87978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
87979     return 0;
87980   }
87981   arg2 = *argp2;
87982   arg3 = (int)jarg3;
87983   {
87984     try {
87985       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87993       };
87994     } catch (...) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87997       };
87998     }
87999   }
88000   jresult = result;
88001   return jresult;
88002 }
88003
88004
88005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
88006   void * jresult ;
88007   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
88008
88009   {
88010     try {
88011       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
88012     } catch (std::out_of_range& e) {
88013       {
88014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88015       };
88016     } catch (std::exception& e) {
88017       {
88018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (...) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88023       };
88024     }
88025   }
88026   jresult = (void *)result;
88027   return jresult;
88028 }
88029
88030
88031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
88032   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
88033
88034   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
88035   {
88036     try {
88037       delete arg1;
88038     } catch (std::out_of_range& e) {
88039       {
88040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88041       };
88042     } catch (std::exception& e) {
88043       {
88044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88045       };
88046     } catch (...) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88049       };
88050     }
88051   }
88052 }
88053
88054
88055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
88056   void * jresult ;
88057   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88058
88059   {
88060     try {
88061       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
88062     } catch (std::out_of_range& e) {
88063       {
88064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88065       };
88066     } catch (std::exception& e) {
88067       {
88068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88069       };
88070     } catch (...) {
88071       {
88072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88073       };
88074     }
88075   }
88076   jresult = (void *)result;
88077   return jresult;
88078 }
88079
88080
88081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
88082   void * jresult ;
88083   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
88084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88085
88086   arg1 = (Dali::Toolkit::Ruler *)jarg1;
88087   {
88088     try {
88089       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
88090     } catch (std::out_of_range& e) {
88091       {
88092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88093       };
88094     } catch (std::exception& e) {
88095       {
88096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88097       };
88098     } catch (...) {
88099       {
88100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88101       };
88102     }
88103   }
88104   jresult = (void *)result;
88105   return jresult;
88106 }
88107
88108
88109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
88110   void * jresult ;
88111   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
88112   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88113
88114   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88115   if (!arg1) {
88116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
88117     return 0;
88118   }
88119   {
88120     try {
88121       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (...) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88133       };
88134     }
88135   }
88136   jresult = (void *)result;
88137   return jresult;
88138 }
88139
88140
88141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
88142   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88143
88144   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88145   {
88146     try {
88147       delete arg1;
88148     } catch (std::out_of_range& e) {
88149       {
88150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88151       };
88152     } catch (std::exception& e) {
88153       {
88154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88155       };
88156     } catch (...) {
88157       {
88158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88159       };
88160     }
88161   }
88162 }
88163
88164
88165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
88166   void * jresult ;
88167   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88168   Dali::Toolkit::Ruler *result = 0 ;
88169
88170   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88171   {
88172     try {
88173       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
88174     } catch (std::out_of_range& e) {
88175       {
88176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88177       };
88178     } catch (std::exception& e) {
88179       {
88180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88181       };
88182     } catch (...) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88185       };
88186     }
88187   }
88188   jresult = (void *)result;
88189   return jresult;
88190 }
88191
88192
88193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
88194   void * jresult ;
88195   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88196   Dali::Toolkit::Ruler *result = 0 ;
88197
88198   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88199   {
88200     try {
88201       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
88202     } catch (std::out_of_range& e) {
88203       {
88204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88205       };
88206     } catch (std::exception& e) {
88207       {
88208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (...) {
88211       {
88212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88213       };
88214     }
88215   }
88216   jresult = (void *)result;
88217   return jresult;
88218 }
88219
88220
88221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
88222   void * jresult ;
88223   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88224   Dali::Toolkit::Ruler *result = 0 ;
88225
88226   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88227   {
88228     try {
88229       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
88230     } catch (std::out_of_range& e) {
88231       {
88232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88233       };
88234     } catch (std::exception& e) {
88235       {
88236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88237       };
88238     } catch (...) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88241       };
88242     }
88243   }
88244   jresult = (void *)result;
88245   return jresult;
88246 }
88247
88248
88249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
88250   void * jresult ;
88251   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88252   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
88253   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88254
88255   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88256   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
88257   if (!arg2) {
88258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
88259     return 0;
88260   }
88261   {
88262     try {
88263       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
88264     } catch (std::out_of_range& e) {
88265       {
88266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88267       };
88268     } catch (std::exception& e) {
88269       {
88270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88271       };
88272     } catch (...) {
88273       {
88274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88275       };
88276     }
88277   }
88278   jresult = (void *)result;
88279   return jresult;
88280 }
88281
88282
88283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
88284   void * jresult ;
88285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88286   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
88288
88289   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88290   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88291   {
88292     try {
88293       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
88294     } catch (std::out_of_range& e) {
88295       {
88296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88297       };
88298     } catch (std::exception& e) {
88299       {
88300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88301       };
88302     } catch (...) {
88303       {
88304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88305       };
88306     }
88307   }
88308   jresult = (void *)result;
88309   return jresult;
88310 }
88311
88312
88313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
88314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88315
88316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88317   {
88318     try {
88319       (arg1)->Reset();
88320     } catch (std::out_of_range& e) {
88321       {
88322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88323       };
88324     } catch (std::exception& e) {
88325       {
88326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88327       };
88328     } catch (...) {
88329       {
88330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88331       };
88332     }
88333   }
88334 }
88335
88336
88337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
88338   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88339   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
88340
88341   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88342   arg2 = (Dali::Toolkit::Ruler *)jarg2;
88343   {
88344     try {
88345       (arg1)->Reset(arg2);
88346     } catch (std::out_of_range& e) {
88347       {
88348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88349       };
88350     } catch (std::exception& e) {
88351       {
88352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88353       };
88354     } catch (...) {
88355       {
88356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88357       };
88358     }
88359   }
88360 }
88361
88362
88363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
88364   void * jresult ;
88365   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88366   Dali::Toolkit::Ruler *result = 0 ;
88367
88368   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88369   {
88370     try {
88371       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
88372     } catch (std::out_of_range& e) {
88373       {
88374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88375       };
88376     } catch (std::exception& e) {
88377       {
88378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88379       };
88380     } catch (...) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88383       };
88384     }
88385   }
88386   jresult = (void *)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
88392   float jresult ;
88393   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88394   float arg2 ;
88395   float arg3 ;
88396   float result;
88397
88398   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88399   arg2 = (float)jarg2;
88400   arg3 = (float)jarg3;
88401   {
88402     try {
88403       result = (float)(*arg1)->Snap(arg2,arg3);
88404     } catch (std::out_of_range& e) {
88405       {
88406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88407       };
88408     } catch (std::exception& e) {
88409       {
88410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88411       };
88412     } catch (...) {
88413       {
88414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88415       };
88416     }
88417   }
88418   jresult = result;
88419   return jresult;
88420 }
88421
88422
88423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
88424   float jresult ;
88425   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88426   float arg2 ;
88427   float result;
88428
88429   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88430   arg2 = (float)jarg2;
88431   {
88432     try {
88433       result = (float)(*arg1)->Snap(arg2);
88434     } catch (std::out_of_range& e) {
88435       {
88436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88437       };
88438     } catch (std::exception& e) {
88439       {
88440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88441       };
88442     } catch (...) {
88443       {
88444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88445       };
88446     }
88447   }
88448   jresult = result;
88449   return jresult;
88450 }
88451
88452
88453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
88454   float jresult ;
88455   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88456   unsigned int arg2 ;
88457   unsigned int *arg3 = 0 ;
88458   bool arg4 ;
88459   float result;
88460
88461   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88462   arg2 = (unsigned int)jarg2;
88463   arg3 = (unsigned int *)jarg3;
88464   arg4 = jarg4 ? true : false;
88465   {
88466     try {
88467       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
88468     } catch (std::out_of_range& e) {
88469       {
88470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88471       };
88472     } catch (std::exception& e) {
88473       {
88474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88475       };
88476     } catch (...) {
88477       {
88478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88479       };
88480     }
88481   }
88482   jresult = result;
88483   return jresult;
88484 }
88485
88486
88487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
88488   unsigned int jresult ;
88489   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88490   float arg2 ;
88491   bool arg3 ;
88492   unsigned int result;
88493
88494   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88495   arg2 = (float)jarg2;
88496   arg3 = jarg3 ? true : false;
88497   {
88498     try {
88499       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
88500     } catch (std::out_of_range& e) {
88501       {
88502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88503       };
88504     } catch (std::exception& e) {
88505       {
88506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88507       };
88508     } catch (...) {
88509       {
88510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88511       };
88512     }
88513   }
88514   jresult = result;
88515   return jresult;
88516 }
88517
88518
88519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
88520   unsigned int jresult ;
88521   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88522   unsigned int result;
88523
88524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88525   {
88526     try {
88527       result = (unsigned int)(*arg1)->GetTotalPages();
88528     } catch (std::out_of_range& e) {
88529       {
88530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (std::exception& e) {
88533       {
88534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542   jresult = result;
88543   return jresult;
88544 }
88545
88546
88547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
88548   int jresult ;
88549   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88550   Dali::Toolkit::Ruler::RulerType result;
88551
88552   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88553   {
88554     try {
88555       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
88556     } catch (std::out_of_range& e) {
88557       {
88558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88559       };
88560     } catch (std::exception& e) {
88561       {
88562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88563       };
88564     } catch (...) {
88565       {
88566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88567       };
88568     }
88569   }
88570   jresult = (int)result;
88571   return jresult;
88572 }
88573
88574
88575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
88576   unsigned int jresult ;
88577   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88578   bool result;
88579
88580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88581   {
88582     try {
88583       result = (bool)(*arg1)->IsEnabled();
88584     } catch (std::out_of_range& e) {
88585       {
88586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88587       };
88588     } catch (std::exception& e) {
88589       {
88590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88591       };
88592     } catch (...) {
88593       {
88594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88595       };
88596     }
88597   }
88598   jresult = result;
88599   return jresult;
88600 }
88601
88602
88603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
88604   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88605
88606   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88607   {
88608     try {
88609       (*arg1)->Enable();
88610     } catch (std::out_of_range& e) {
88611       {
88612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88613       };
88614     } catch (std::exception& e) {
88615       {
88616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88617       };
88618     } catch (...) {
88619       {
88620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88621       };
88622     }
88623   }
88624 }
88625
88626
88627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
88628   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88629
88630   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88631   {
88632     try {
88633       (*arg1)->Disable();
88634     } catch (std::out_of_range& e) {
88635       {
88636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88637       };
88638     } catch (std::exception& e) {
88639       {
88640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88641       };
88642     } catch (...) {
88643       {
88644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88645       };
88646     }
88647   }
88648 }
88649
88650
88651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
88652   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88653   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
88654   Dali::Toolkit::RulerDomain *argp2 ;
88655
88656   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88657   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
88658   if (!argp2) {
88659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
88660     return ;
88661   }
88662   arg2 = *argp2;
88663   {
88664     try {
88665       (*arg1)->SetDomain(arg2);
88666     } catch (std::out_of_range& e) {
88667       {
88668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88669       };
88670     } catch (std::exception& e) {
88671       {
88672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88677       };
88678     }
88679   }
88680 }
88681
88682
88683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
88684   void * jresult ;
88685   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88686   Dali::Toolkit::RulerDomain *result = 0 ;
88687
88688   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88689   {
88690     try {
88691       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
88692     } catch (std::out_of_range& e) {
88693       {
88694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88695       };
88696     } catch (std::exception& e) {
88697       {
88698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88699       };
88700     } catch (...) {
88701       {
88702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88703       };
88704     }
88705   }
88706   jresult = (void *)result;
88707   return jresult;
88708 }
88709
88710
88711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
88712   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88713
88714   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88715   {
88716     try {
88717       (*arg1)->DisableDomain();
88718     } catch (std::out_of_range& e) {
88719       {
88720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88721       };
88722     } catch (std::exception& e) {
88723       {
88724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88725       };
88726     } catch (...) {
88727       {
88728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88729       };
88730     }
88731   }
88732 }
88733
88734
88735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
88736   float jresult ;
88737   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88738   float arg2 ;
88739   float arg3 ;
88740   float arg4 ;
88741   float result;
88742
88743   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88744   arg2 = (float)jarg2;
88745   arg3 = (float)jarg3;
88746   arg4 = (float)jarg4;
88747   {
88748     try {
88749       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
88750     } catch (std::out_of_range& e) {
88751       {
88752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88753       };
88754     } catch (std::exception& e) {
88755       {
88756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88757       };
88758     } catch (...) {
88759       {
88760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88761       };
88762     }
88763   }
88764   jresult = result;
88765   return jresult;
88766 }
88767
88768
88769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
88770   float jresult ;
88771   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88772   float arg2 ;
88773   float arg3 ;
88774   float result;
88775
88776   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88777   arg2 = (float)jarg2;
88778   arg3 = (float)jarg3;
88779   {
88780     try {
88781       result = (float)(*arg1)->Clamp(arg2,arg3);
88782     } catch (std::out_of_range& e) {
88783       {
88784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88785       };
88786     } catch (std::exception& e) {
88787       {
88788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88789       };
88790     } catch (...) {
88791       {
88792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88793       };
88794     }
88795   }
88796   jresult = result;
88797   return jresult;
88798 }
88799
88800
88801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
88802   float jresult ;
88803   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88804   float arg2 ;
88805   float result;
88806
88807   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88808   arg2 = (float)jarg2;
88809   {
88810     try {
88811       result = (float)(*arg1)->Clamp(arg2);
88812     } catch (std::out_of_range& e) {
88813       {
88814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88815       };
88816     } catch (std::exception& e) {
88817       {
88818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88819       };
88820     } catch (...) {
88821       {
88822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88823       };
88824     }
88825   }
88826   jresult = result;
88827   return jresult;
88828 }
88829
88830
88831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
88832   float jresult ;
88833   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88834   float arg2 ;
88835   float arg3 ;
88836   float arg4 ;
88837   Dali::Toolkit::ClampState *arg5 = 0 ;
88838   float result;
88839
88840   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88841   arg2 = (float)jarg2;
88842   arg3 = (float)jarg3;
88843   arg4 = (float)jarg4;
88844   arg5 = (Dali::Toolkit::ClampState *)jarg5;
88845   if (!arg5) {
88846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
88847     return 0;
88848   }
88849   {
88850     try {
88851       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
88852     } catch (std::out_of_range& e) {
88853       {
88854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88855       };
88856     } catch (std::exception& e) {
88857       {
88858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88859       };
88860     } catch (...) {
88861       {
88862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88863       };
88864     }
88865   }
88866   jresult = result;
88867   return jresult;
88868 }
88869
88870
88871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
88872   float jresult ;
88873   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88874   float arg2 ;
88875   float arg3 ;
88876   float arg4 ;
88877   float arg5 ;
88878   float result;
88879
88880   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88881   arg2 = (float)jarg2;
88882   arg3 = (float)jarg3;
88883   arg4 = (float)jarg4;
88884   arg5 = (float)jarg5;
88885   {
88886     try {
88887       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
88888     } catch (std::out_of_range& e) {
88889       {
88890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88891       };
88892     } catch (std::exception& e) {
88893       {
88894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88895       };
88896     } catch (...) {
88897       {
88898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88899       };
88900     }
88901   }
88902   jresult = result;
88903   return jresult;
88904 }
88905
88906
88907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
88908   float jresult ;
88909   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88910   float arg2 ;
88911   float arg3 ;
88912   float arg4 ;
88913   float result;
88914
88915   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88916   arg2 = (float)jarg2;
88917   arg3 = (float)jarg3;
88918   arg4 = (float)jarg4;
88919   {
88920     try {
88921       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
88922     } catch (std::out_of_range& e) {
88923       {
88924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88925       };
88926     } catch (std::exception& e) {
88927       {
88928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88933       };
88934     }
88935   }
88936   jresult = result;
88937   return jresult;
88938 }
88939
88940
88941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
88942   float jresult ;
88943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88944   float arg2 ;
88945   float arg3 ;
88946   float result;
88947
88948   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88949   arg2 = (float)jarg2;
88950   arg3 = (float)jarg3;
88951   {
88952     try {
88953       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
88954     } catch (std::out_of_range& e) {
88955       {
88956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88957       };
88958     } catch (std::exception& e) {
88959       {
88960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88961       };
88962     } catch (...) {
88963       {
88964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88965       };
88966     }
88967   }
88968   jresult = result;
88969   return jresult;
88970 }
88971
88972
88973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
88974   float jresult ;
88975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
88976   float arg2 ;
88977   float result;
88978
88979   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
88980   arg2 = (float)jarg2;
88981   {
88982     try {
88983       result = (float)(*arg1)->SnapAndClamp(arg2);
88984     } catch (std::out_of_range& e) {
88985       {
88986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88987       };
88988     } catch (std::exception& e) {
88989       {
88990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88991       };
88992     } catch (...) {
88993       {
88994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88995       };
88996     }
88997   }
88998   jresult = result;
88999   return jresult;
89000 }
89001
89002
89003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
89004   float jresult ;
89005   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89006   float arg2 ;
89007   float arg3 ;
89008   float arg4 ;
89009   float arg5 ;
89010   Dali::Toolkit::ClampState *arg6 = 0 ;
89011   float result;
89012
89013   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89014   arg2 = (float)jarg2;
89015   arg3 = (float)jarg3;
89016   arg4 = (float)jarg4;
89017   arg5 = (float)jarg5;
89018   arg6 = (Dali::Toolkit::ClampState *)jarg6;
89019   if (!arg6) {
89020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
89021     return 0;
89022   }
89023   {
89024     try {
89025       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
89026     } catch (std::out_of_range& e) {
89027       {
89028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89029       };
89030     } catch (std::exception& e) {
89031       {
89032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89033       };
89034     } catch (...) {
89035       {
89036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89037       };
89038     }
89039   }
89040   jresult = result;
89041   return jresult;
89042 }
89043
89044
89045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
89046   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89047
89048   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89049   {
89050     try {
89051       (*arg1)->Reference();
89052     } catch (std::out_of_range& e) {
89053       {
89054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89055       };
89056     } catch (std::exception& e) {
89057       {
89058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89059       };
89060     } catch (...) {
89061       {
89062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89063       };
89064     }
89065   }
89066 }
89067
89068
89069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
89070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89071
89072   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89073   {
89074     try {
89075       (*arg1)->Unreference();
89076     } catch (std::out_of_range& e) {
89077       {
89078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89079       };
89080     } catch (std::exception& e) {
89081       {
89082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89083       };
89084     } catch (...) {
89085       {
89086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89087       };
89088     }
89089   }
89090 }
89091
89092
89093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
89094   int jresult ;
89095   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
89096   int result;
89097
89098   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
89099   {
89100     try {
89101       result = (int)(*arg1)->ReferenceCount();
89102     } catch (std::out_of_range& e) {
89103       {
89104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89105       };
89106     } catch (std::exception& e) {
89107       {
89108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89109       };
89110     } catch (...) {
89111       {
89112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89113       };
89114     }
89115   }
89116   jresult = result;
89117   return jresult;
89118 }
89119
89120
89121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
89122   unsigned int jresult ;
89123   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89124   bool result;
89125
89126   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89127   {
89128     try {
89129       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
89130     } catch (std::out_of_range& e) {
89131       {
89132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89133       };
89134     } catch (std::exception& e) {
89135       {
89136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89137       };
89138     } catch (...) {
89139       {
89140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89141       };
89142     }
89143   }
89144   jresult = result;
89145   return jresult;
89146 }
89147
89148
89149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
89150   unsigned long jresult ;
89151   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89152   std::size_t result;
89153
89154   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89155   {
89156     try {
89157       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
89158     } catch (std::out_of_range& e) {
89159       {
89160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89161       };
89162     } catch (std::exception& e) {
89163       {
89164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89165       };
89166     } catch (...) {
89167       {
89168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89169       };
89170     }
89171   }
89172   jresult = (unsigned long)result;
89173   return jresult;
89174 }
89175
89176
89177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
89178   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89179   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89180
89181   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89182   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89183   {
89184     try {
89185       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
89186     } catch (std::out_of_range& e) {
89187       {
89188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89189       };
89190     } catch (std::exception& e) {
89191       {
89192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89193       };
89194     } catch (...) {
89195       {
89196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89197       };
89198     }
89199   }
89200 }
89201
89202
89203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
89204   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89205   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
89206
89207   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89208   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
89209   {
89210     try {
89211       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
89212     } catch (std::out_of_range& e) {
89213       {
89214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89215       };
89216     } catch (std::exception& e) {
89217       {
89218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89219       };
89220     } catch (...) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89223       };
89224     }
89225   }
89226 }
89227
89228
89229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
89230   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89231   Dali::Toolkit::Control arg2 ;
89232   Dali::Toolkit::Control *argp2 ;
89233
89234   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89235   argp2 = (Dali::Toolkit::Control *)jarg2;
89236   if (!argp2) {
89237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
89238     return ;
89239   }
89240   arg2 = *argp2;
89241   {
89242     try {
89243       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
89244     } catch (std::out_of_range& e) {
89245       {
89246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89247       };
89248     } catch (std::exception& e) {
89249       {
89250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89251       };
89252     } catch (...) {
89253       {
89254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89255       };
89256     }
89257   }
89258 }
89259
89260
89261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
89262   void * jresult ;
89263   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
89264
89265   {
89266     try {
89267       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
89268     } catch (std::out_of_range& e) {
89269       {
89270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89271       };
89272     } catch (std::exception& e) {
89273       {
89274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89275       };
89276     } catch (...) {
89277       {
89278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89279       };
89280     }
89281   }
89282   jresult = (void *)result;
89283   return jresult;
89284 }
89285
89286
89287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
89288   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
89289
89290   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
89291   {
89292     try {
89293       delete arg1;
89294     } catch (std::out_of_range& e) {
89295       {
89296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89297       };
89298     } catch (std::exception& e) {
89299       {
89300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89301       };
89302     } catch (...) {
89303       {
89304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89305       };
89306     }
89307   }
89308 }
89309
89310 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
89311   Dali::RefObject *result = NULL;
89312
89313   if (arg1)
89314   {
89315     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
89316   }
89317   return result;
89318 }
89319
89320 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
89321     return (Dali::RefObject *)jarg1;
89322 }
89323
89324 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
89325     return (Dali::SignalObserver *)jarg1;
89326 }
89327
89328 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
89329     return (Dali::ConnectionTrackerInterface *)jarg1;
89330 }
89331
89332 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
89333     return (Dali::BaseHandle *)jarg1;
89334 }
89335
89336 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
89337     return (Dali::BaseHandle *)jarg1;
89338 }
89339
89340 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
89341     return (Dali::BaseHandle *)jarg1;
89342 }
89343
89344 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
89345     return (Dali::BaseHandle *)jarg1;
89346 }
89347
89348 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
89349     return (Dali::BaseHandle *)jarg1;
89350 }
89351
89352 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
89353     return (Dali::BaseHandle *)jarg1;
89354 }
89355
89356 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
89357     return (Dali::BaseHandle *)jarg1;
89358 }
89359
89360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
89361     return (Dali::BaseHandle *)jarg1;
89362 }
89363
89364 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
89365     return (Dali::BaseHandle *)jarg1;
89366 }
89367
89368 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
89369     return (Dali::BaseHandle *)jarg1;
89370 }
89371
89372 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
89373     return (Dali::BaseHandle *)jarg1;
89374 }
89375
89376 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
89377     return (Dali::BaseHandle *)jarg1;
89378 }
89379
89380 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
89381     return (Dali::BaseHandle *)jarg1;
89382 }
89383
89384 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
89385     return (Dali::Handle *)jarg1;
89386 }
89387
89388 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
89389     return (Dali::Handle *)jarg1;
89390 }
89391
89392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
89393     return (Dali::BaseHandle *)jarg1;
89394 }
89395
89396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
89397     return (Dali::BaseHandle *)jarg1;
89398 }
89399
89400 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
89401     return (Dali::Handle *)jarg1;
89402 }
89403
89404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
89405     return (Dali::BaseHandle *)jarg1;
89406 }
89407
89408 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
89409     return (Dali::Handle *)jarg1;
89410 }
89411
89412 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
89413     return (Dali::GestureDetector *)jarg1;
89414 }
89415
89416 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
89417     return (Dali::Gesture *)jarg1;
89418 }
89419
89420 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
89421     return (Dali::Handle *)jarg1;
89422 }
89423
89424 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
89425     return (Dali::Actor *)jarg1;
89426 }
89427
89428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
89429     return (Dali::BaseHandle *)jarg1;
89430 }
89431
89432 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
89433     return (Dali::RefObject *)jarg1;
89434 }
89435
89436 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
89437     return (Dali::Actor *)jarg1;
89438 }
89439
89440 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
89441     return (Dali::GestureDetector *)jarg1;
89442 }
89443
89444 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
89445     return (Dali::Gesture *)jarg1;
89446 }
89447
89448 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
89449     return (Dali::GestureDetector *)jarg1;
89450 }
89451
89452 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
89453     return (Dali::Gesture *)jarg1;
89454 }
89455
89456 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
89457     return (Dali::GestureDetector *)jarg1;
89458 }
89459
89460 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
89461     return (Dali::Gesture *)jarg1;
89462 }
89463
89464 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
89465     return (Dali::BaseHandle *)jarg1;
89466 }
89467
89468 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
89469     return (Dali::Handle *)jarg1;
89470 }
89471
89472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
89473     return (Dali::BaseHandle *)jarg1;
89474 }
89475
89476 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
89477     return (Dali::Handle *)jarg1;
89478 }
89479
89480 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
89481     return (Dali::Handle *)jarg1;
89482 }
89483
89484 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
89485     return (Dali::Image *)jarg1;
89486 }
89487
89488 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
89489     return (Dali::Image *)jarg1;
89490 }
89491
89492 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
89493     return (Dali::Image *)jarg1;
89494 }
89495
89496 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
89497     return (Dali::RefObject *)jarg1;
89498 }
89499
89500 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
89501     return (Dali::Image *)jarg1;
89502 }
89503
89504 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
89505     return (Dali::Image *)jarg1;
89506 }
89507
89508 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
89509     return (Dali::ResourceImage *)jarg1;
89510 }
89511
89512 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
89513     return (Dali::Actor *)jarg1;
89514 }
89515
89516 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
89517     return (Dali::BaseHandle *)jarg1;
89518 }
89519
89520 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
89521     return (Dali::BaseHandle *)jarg1;
89522 }
89523
89524
89525 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
89526     return (Dali::BaseHandle *)jarg1;
89527 }
89528
89529 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
89530     return (Dali::BaseHandle *)jarg1;
89531 }
89532
89533 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
89534     return (Dali::CustomActorImpl *)jarg1;
89535 }
89536
89537 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
89538     return (Dali::CustomActor *)jarg1;
89539 }
89540
89541 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
89542     return (Dali::BaseHandle *)jarg1;
89543 }
89544
89545 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
89546     return (Dali::Toolkit::Control *)jarg1;
89547 }
89548
89549 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
89550     return (Dali::Toolkit::Control *)jarg1;
89551 }
89552
89553 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
89554     return (Dali::Toolkit::Button *)jarg1;
89555 }
89556
89557 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
89558     return (Dali::Toolkit::Button *)jarg1;
89559 }
89560
89561 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
89562     return (Dali::Toolkit::Button *)jarg1;
89563 }
89564
89565 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
89566     return (Dali::Toolkit::Control *)jarg1;
89567 }
89568
89569 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
89570     return (Dali::Toolkit::Control *)jarg1;
89571 }
89572
89573 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
89574     return (Dali::Toolkit::Control *)jarg1;
89575 }
89576
89577 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
89578     return (Dali::Toolkit::Control *)jarg1;
89579 }
89580
89581 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
89582     return (Dali::Toolkit::Control *)jarg1;
89583 }
89584
89585 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
89586     return (Dali::RefObject *)jarg1;
89587 }
89588
89589 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
89590     return (Dali::Toolkit::Scrollable *)jarg1;
89591 }
89592
89593 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
89594     return (Dali::BaseHandle *)jarg1;
89595 }
89596
89597 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
89598     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
89599 }
89600
89601 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
89602     return (Dali::RefObject *)jarg1;
89603 }
89604
89605 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
89606     return (Dali::Toolkit::Ruler *)jarg1;
89607 }
89608
89609 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
89610     return (Dali::Toolkit::Ruler *)jarg1;
89611 }
89612
89613 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
89614     return (Dali::Toolkit::Scrollable *)jarg1;
89615 }
89616
89617 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
89618     return (Dali::Toolkit::Control *)jarg1;
89619 }
89620
89621
89622 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
89623     return (Dali::Toolkit::Control *)jarg1;
89624 }
89625
89626 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
89627     return (Dali::BaseHandle *)jarg1;
89628 }
89629
89630 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
89631     return (Dali::BaseHandle *)jarg1;
89632 }
89633
89634 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
89635     return (Dali::Toolkit::Control *)jarg1;
89636 }
89637
89638 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
89639     return (Dali::Toolkit::Control *)jarg1;
89640 }
89641
89642 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
89643     return (Dali::Toolkit::Control *)jarg1;
89644 }
89645
89646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
89647     return (Dali::Toolkit::Control *)jarg1;
89648 }
89649
89650 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
89651     return (Dali::Toolkit::Control *)jarg1;
89652 }
89653
89654 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
89655     return (Dali::Toolkit::Control *)jarg1;
89656 }
89657
89658 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
89659     return (Dali::Toolkit::PageTurnView *)jarg1;
89660 }
89661
89662 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
89663     return (Dali::Toolkit::PageTurnView *)jarg1;
89664 }
89665
89666 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
89667     return (Dali::Toolkit::Button *)jarg1;
89668 }
89669
89670 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
89671     return (Dali::BaseHandle *)jarg1;
89672 }
89673
89674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
89675     return (Dali::BaseHandle *)jarg1;
89676 }
89677
89678 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
89679     return (Dali::BaseHandle *)jarg1;
89680 }
89681
89682
89683 #ifdef __cplusplus
89684 }
89685 #endif